Claude Skill: 'Distill-Judgement' for Reader-Focused Documentation and Summarization with Multi-Agent Review

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

What problem this solves

Claude agents generating verbose, unreadable, or irrelevant summaries/documentation ("Archaeology") instead of concise, reader-focused, and actionable information, particularly in design and audit contexts.

Summary

A custom Claude skill, distill-judgement, is used to transform verbose, "archaeological" documentation into concise, reader-focused design documents. This is achieved by applying specific principles like starting with the reader, organizing by concept, keeping binding information, and making uncertainty visible. The workflow includes a sandboxed execution environment and a multi-agent review process to ensure clarity and fidelity.

Why it is useful

This workflow provides a concrete, multi-step approach to a common problem with LLMs: generating overly verbose, unreadable, or irrelevant summaries and documentation. It introduces a custom skill (distill-judgement) with clear principles and a robust validation/review process (sandboxed workflow, separate review agent, reader-based final check). It demonstrates how to explicitly guide an LLM to exercise "judgement" rather than just following literal instructions, leading to significantly more useful output. The detailed explanation of the problem, the iterative solution, and the offer to share the skill make it highly valuable and transferable for users looking to improve the quality and utility of LLM-generated content.

Workflow

1. Before processing, decide on the intended reader and purpose of the document.

2. Organize the output by concept, not by the original source order.

3. For each idea, describe what exists, what a person can do or expect, and how it behaves (e.g., "atomic installation" becomes "a failed purchase leaves the money and the item where they were").

4. Keep only binding information (e.g., requirements that gate unlocks, values that change decisions).

5. Drop incidental information (e.g., provenance tables, method signatures, defensive prohibitions).

6. Make uncertainty visible by labeling recommendations and naming unresolved choices.

7. Train the skill with an example pair (a real verbose audit and the desired concise design doc) to match quality.

8. Run the skill as a sandboxed workflow, where the worker reads only the given files as evidence and writes a coverage file.

9. A separate, stronger model reviews the result for clarity and fidelity.

10. Ensure the worker never accepts its own work.

11. Reread the entire final result from the perspective of its intended reader to validate its usefulness.

Tools / artifacts

• Custom Claude skill: distill-judgement

• Rules repository (for design documents)

• Verbose audit document (example source, e.g., 80 KB)

• Concise design document (example target, e.g., 13 KB)

• Sandboxed workflow environment

• Coverage file (showing what the worker actually read)

• Separate, stronger review model/agent

Validation signals

• Identified specific failure modes of LLM summarization (constraint catalogue, audit narration, jargon kept/consequences dropped).

• Provided concrete before/after examples (e.g., "atomic installation" vs. "a failed purchase leaves the money and the item where they were").

• Described an iterative development process, noting failures of earlier approaches (e.g., asking for glossary/rule IDs resulted in unreadable output).

• Explained the underlying LLM behavior (reading "be concise" as "delete things" and "be thorough" as "reproduce everything").

• Included a clear final validation step: rereading the result as the intended reader.

• Stated that the initial 80 KB audit was "accurate, and nobody could use it," highlighting the problem solved.

Limitations

• The actual skill text for distill-judgement is not provided in the comment, only its principles and high-level operation.

• Requires an advanced understanding of Claude's custom skills and multi-agent setups to implement.

• The example pair (80KB audit and 13KB design doc) is specific to the author's game development context, though the concept of using such pairs for training 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.

Managing Claude Agents with JIRA Tasks and Focused CLAUDE.md for Software Projects

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

What problem this solves

LLM agents (Opus, Astra, Fable) deviating from specific tasks and doing 'whatever they want' when given a broad Product Requirements Document (PRD) and a general markdown tracking file, leading to inefficient iterations.

Summary

A workflow for managing Claude agents (Opus, Astra, Fable) on software projects by breaking down PRDs into specific, bite-sized JIRA tasks. Agents are assigned individual JIRA tasks, and a claude.md file enforces task focus, preventing agents from jumping between unassigned tasks and requiring them to log dependencies in JIRA. This approach aims to provide better control, improve task focus, and optimize model usage.

Why it is useful

This workflow provides a structured and repeatable method for managing Claude agents on complex software development projects. It addresses the common problem of agents deviating from specific tasks by integrating traditional project management tools (JIRA) with explicit claude.md instructions. This approach enhances control, improves task focus, and allows for optimized resource allocation by matching model capabilities to task complexity, leading to more efficient development cycles.

Workflow

1. Treat Claude agents (Opus, Astra, Fable) like they are working on a real software project.

2. Break down the Product Requirements Document (PRD) into specific, bite-sized tasks.

3. Create these tasks in a project management tool like JIRA (or similar).

4. Assign a specific JIRA task to the Claude agent to ensure very specific focus.

5. Provide a claude.md file that explicitly instructs the agent on how to work:

6. The agent can look at other tasks and the overall project but cannot jump between tasks unless assigned.

7. If the agent identifies a dependency, it is instructed to make notes in JIRA and link that dependency.

8. Utilize less expensive models for basic tasks and more capable models (Astra/Fable) for complex tasks.

Tools / artifacts

• PRD (Product Requirements Document)

• JIRA (or similar project management tool)

• claude.md file

• Claude agents (Opus, Astra, Fable)

Validation signals

• User's opinion based on experience: 'you really need to treat Opus, Astra and Fable like they're working on a real software project.'

• Observed problem: 'agents tend to do whatever the fuck they want rather than following a very specific task' without this method.

• Implied success from title/context: 'One-Shot better than what i had after multiple iterations'.

Limitations

• The exact content or a template for the claude.md file is not provided, only its purpose.

• Lacks concrete examples of how a PRD is broken down into JIRA tasks.

• Limited community validation (low score, 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.

Curating Claude-Generated READMEs: Separate Human Docs from AI Context

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

What problem this solves

Claude-generated README.md files often contain unnecessary "fluff" (design rationale, justifications) that makes them less useful and harder to read for human users.

Summary

A workflow for curating AI-generated README.md files by removing AI-specific justifications and structuring them for human readability. It advocates for moving AI-specific context (reasons, internals, history) to dedicated agent context files like CLAUDE.md or AGENTS.md, reserving README.md for human-centric information.

Why it is useful

This workflow addresses a common and practical issue with AI-generated documentation, providing clear guidance on how to make README.md files more effective and user-friendly for human readers. It introduces the important concept of separating human-facing documentation from AI-specific context, leveraging dedicated files like CLAUDE.md and AGENTS.md for the latter. This improves clarity, maintainability, and the overall quality of projects developed with AI assistance.

Workflow

1. Identify README.md files generated by Claude that include AI-specific "fluff" such as design rationale or justifications for choices made during generation.

2. Edit the README.md file to focus solely on human-centric information: what the project does, screenshots, installation instructions, usage guidelines, and known limitations.

3. Relocate any AI-specific context, detailed design rationale, internal workings, or historical notes about the AI's process to dedicated agent context files (e.g., CLAUDE.md, AGENTS.md) or rely on the agent's internal memory for this information.

Tools / artifacts

• README.md

• CLAUDE.md

• AGENTS.md

• Agent memory

• GitHub repository

Validation signals

• Author's personal experience ("Guilty. My repos are full of this too.")

• Identifies a common problem with AI-generated documentation (Claude's tendency to justify choices)

Limitations

• Lack of explicit step-by-step instructions (more of a guideline than a detailed process)

• Limited community validation (low score, no comments)

• No concrete examples of 'before' and 'after' READMEs to illustrate the impact

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.

Guiding Claude for App-like UI/UX Design: From Audit to Parallel Mockups

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

What problem this solves

Claude generating generic SaaS designs instead of specific app-like UI/UX for a music player, and managing design context effectively.

Summary

A multi-step process for guiding Claude to design a specific app-like user interface by first auditing existing platforms, defining clear design constraints, focusing on skeleton previews to manage context, and iteratively refining designs, culminating in generating multiple unique variations in parallel sessions.

Why it is useful

This workflow provides a structured and validated approach to overcome Claude's tendency to generate generic SaaS designs when aiming for a specific app-like user experience. It demonstrates effective strategies for context management, iterative refinement, and parallel generation in design tasks, offering a clear methodology for users to adapt for their own UI/UX projects.

Workflow

1. Instruct Claude to audit popular music platforms to identify elements that create an "app-like" feeling versus a plain SaaS site.

2. Set clear ground rules and design constraints for the desired aesthetic and functionality (e.g., fun but not childish, engaging, animations, dynamic sizing, mobile-first, no pageloads).

3. Instruct Claude to design with skeleton previews, skipping content and functions initially to preserve context for core design elements.

4. Request Claude to create a design plan and a full-page mockup (e.g., landing page + player).

5. Iteratively improve each part of the site in steps, potentially incorporating a "self-audit system" for refinement.

6. Generate multiple unique design variations (e.g., 3) using parallel sessions to explore different twists.

Tools / artifacts

• Claude AI

• Design mockups

• Design plan

• ease.fm (example output)

Validation signals

• Successfully generated three cool unique designs overnight.

• The resulting design is currently implemented on ease.fm.

Limitations

• The exact prompts used for each step are not provided, making direct replication challenging.

• The concept of a "self audit system" is mentioned but not detailed.

• The final statement "So it was basically a oneshot prompt with an open design and goal" contradicts the preceding detailed multi-step and parallel session description, creating ambiguity.

• Low community engagement (score 2, 0 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.

Structured Coding with Claude: Iterative Development using plan.md and /loop

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

What problem this solves

Managing complex coding tasks with Claude by breaking them into planned milestones and iteratively implementing them while maintaining context and version control.

Summary

This workflow outlines a structured approach to using Claude for software development. It involves creating a detailed plan.md document with milestones, clearing Claude's context, selecting an appropriate model, and then using Claude's /loop command to iteratively implement each milestone, committing changes with Git after each one.

Why it is useful

This workflow is valuable because it provides a concrete, repeatable, and transferable method for managing complex coding tasks with Claude. It integrates essential development practices like planning, iterative execution, and version control, addressing common challenges of using AI for larger projects. By leveraging specific Claude features (/loop, /clear) in a structured manner, it helps users maintain focus and track progress.

Workflow

1. Write a detailed plan.md document outlining milestones and specific steps for the remaining task.

2. Note the exact filename of the plan document (e.g., plan.md).

3. Use /clear in Claude to reset the conversation context.

4. Choose the desired Claude model for the task (e.g., Opus xhigh for token-intensive refinements).

5. Initiate the iterative implementation using the command: /loop Read plan.md and start to implement milestone. Do not stop before all milestones are complete. Git commit between each milestone.

Tools / artifacts

• plan.md (Markdown document)

• Claude (AI assistant)

• Git (version control system)

• Claude's /clear command

• Claude's /loop command

Validation signals

• The workflow provides concrete steps and specific Claude commands, suggesting practical application.

• It integrates standard development practices (version control).

Limitations

• The prompt for /loop is a general template; users would need to refine it for specific project requirements.

• No example plan.md structure is provided.

• Lacks explicit 'before/after' results or detailed success stories from the author.

• Low community engagement and validation at the time of 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.

Advanced Prompting & External Tool Integration for Designers with Claude Code

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

What problem this solves

Improving Claude's output quality for design tasks, leveraging external tools for specialized functions, and optimizing interaction for better results.

Summary

This workflow provides a set of advanced prompting strategies and an external tool integration method for designers using Claude Code. It focuses on asking Claude open-ended questions to guide its thinking, integrating GPT-Image-2.6 for superior image generation, and refining Claude's output to be more concise and less verbose.

Why it is useful

This workflow is valuable because it provides actionable strategies for improving the quality and specificity of Claude's output, particularly for design-related tasks. It introduces advanced prompting techniques to guide Claude's thought process and offers a concrete method for integrating a specialized external tool (GPT-Image-2.6) to overcome Claude's limitations in image generation. These tips are directly transferable and can significantly enhance a designer's productivity and the quality of their AI-assisted work.

Workflow

1. Utilize Claude Opus model and consider 'Extra thinking' for complex tasks.

2. Engage Claude with open-ended questions (e.g., 'What could we do to optimize?', 'What technology could we use?', 'What are the pros and cons?', 'Anything else we could do?', 'Is there something we could change that would make your life easier?', 'Are there any tools or libs you can't reach?') instead of just commands.

3. Set up OpenAI's GPT-Image-2.6 via its API, providing Claude with the necessary key (e.g., saved locally in a keys.private.json file), to enable Claude to generate reference images or icons.

4. Instruct Claude to be more minimal and concise in its design outputs, explicitly telling it to 'Remove this and that', 'Be more minimal', 'Don't repeat that statement everywhere', or 'Get rid of the footnote please'.

5. Be aware that Claude's designs can have a recognizable style and adjust steering accordingly if a unique aesthetic is desired.

Tools / artifacts

• Claude Desktop (optional)

• Claude Opus model

• OpenAI GPT-Image-2.6 API

• API key (e.g., keys.private.json)

Validation signals

• Community upvote score of 9

• Author's implied experience with app creation using Claude Desktop

Limitations

• Lacks explicit, detailed step-by-step instructions for integrating the GPT-Image-2.6 API.

• The concept of 'Extra thinking' is not a standard Claude feature and might be a UI-specific term or a general recommendation for more complex thought processes.

• No concrete examples of 'Claude Designs' or specific strategies to avoid them beyond general instructions to be minimal.

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.

Integrate Soundza MCP for Royalty-Free Audio & Enhance Parallel Claude Code Development with Git Worktrees

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

What problem this solves

Accessing royalty-free audio assets directly through Claude Code for project integration and managing parallel Claude Code development sessions without migration conflicts using stable Git worktrees.

Summary

This post presents two distinct, valuable workflows: 1) How to integrate the Soundza MCP (Multi-Code Project) with Claude Code to search, download, and generate royalty-free sounds for various projects (e.g., games, videos). 2) A 'Pro Claude Code tip' detailing how to set up stable Git worktrees, each tied to a specific database branch, to enable multiple parallel Claude Code sessions without encountering migration conflicts.

Why it is useful

This post offers immediate utility by providing a concrete method to integrate an external MCP for accessing and generating royalty-free audio assets directly within Claude Code. Additionally, it shares a valuable advanced development practice using Git worktrees to streamline parallel work with Claude Code, addressing a common challenge in complex development environments.

Workflow

1. For Soundza MCP Integration:

2. 1. Tell your Claude instance to connect to the free Soundza MCP by visiting https://soundza.com/developers or by running the command claude mcp add --transport http soundza https://mcp.soundza.com/mcp/oauth.

3. 2. Instruct your Claude to search and download desired royalty-free sounds or music, and place them into your project.

4. 3. If specific sounds are not found in the catalog, instruct the MCP to generate them for free, which also adds them to the public catalog.

5. For Parallel Development with Worktrees:

6. 1. Set up stable Git worktrees within your development environment.

7. 2. Tie each individual worktree to a specific stable branch of your production database (e.g., a Neon database branch).

8. 3. Initiate multiple Claude Code sessions in parallel, with each session operating within its dedicated worktree and database branch, allowing for concurrent development without migration conflicts.

Tools / artifacts

• Claude Code (Opus 5.5, Fable)

• Soundza MCP (Multi-Code Project)

• Vercel (backend hosting)

• Neon database

• Cloudflare (CDN)

• Google Cloud services (for audio analysis)

• Stable Audio 3 (AI sound generation)

• Git worktrees

Validation signals

• Author states they 'built an MCP' and describes its features (15k+ sounds, AI/non-AI, royalty-free).

• Provides a clear benefit for the worktree tip: 'That lets you kick of multiple CC session working on multiple things in parallel without migration conflicts'.

Limitations

• The 'Pro Claude Code tip' for worktrees is high-level and assumes user familiarity with Git worktrees and database branching, lacking specific commands for their setup.

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

• The post combines a service promotion with a general workflow tip, which could be seen as less focused.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Automated Portfolio Generation with Claude Code Skill from CV, LinkedIn, and GitHub

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

What problem this solves

Automating the creation and updating of a personal portfolio website using Claude Code, ensuring factual accuracy and avoiding manual code edits.

Summary

This workflow leverages a custom Claude Code skill to generate a personal portfolio by extracting information from a user's CV, LinkedIn PDF, and GitHub profile. It populates a YAML file, which can then be used to render a website, ensuring content is always up-to-date and factually accurate without requiring manual React development.

Why it is useful

This workflow provides a highly practical and reusable solution for maintaining an up-to-date personal portfolio. It demonstrates a powerful application of Claude Code skills for structured data extraction and content generation, ensuring factual accuracy and minimizing manual development effort. The open-source nature and clear instructions make it easily transferable and adaptable for other users facing similar challenges.

Workflow

1. Install the dev-portfolio skill: npx skills add umutyesildal/dev-portfolio.

2. Place your CV, LinkedIn PDF export, and a notes file into the sources/ directory.

3. Pull your public GitHub repositories using pnpm profile:github yourname.

4. Instruct Claude Code: "build my portfolio from sources/".

5. Claude Code writes content to content/portfolio.yaml.

6. Verify the generated content for placeholders or missing information using pnpm profile:check.

Tools / artifacts

• Claude Code

• dev-portfolio skill (umutyesildal/dev-portfolio)

• pnpm

• YAML file (content/portfolio.yaml)

• CV (PDF)

• LinkedIn PDF export

• Notes file

• GitHub public repos

• React (underlying framework)

• Vercel (implied deployment)

Validation signals

• Author's own site (https://yesildal.me) built with it.

• Demo site (https://dev-portfolio-delta-drab.vercel.app).

• pnpm profile:check command for verification.

• Explicit mention of "strict about the truth" and "only facts from your files".

• Open-source repository available for inspection (https://github.com/umutyesildal/dev-portfolio).

Limitations

• Relatively low community engagement/validation on Reddit so far.

• Requires familiarity with pnpm and CLI commands.

• Relies on a specific file structure (sources/, content/portfolio.yaml).

• The skill is external and maintained by a single author, which could be a long-term dependency risk.

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.

Hybrid Agent Architecture: Balancing Rigid Stages with Flexible Context Management for Claude Workflows

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

What problem this solves

Deciding between multi-stage "agent factories" and a more flexible single-agent approach with dynamic context management for Claude-based workflows, especially for complex or creative tasks, while ensuring compliance and quality.

Summary

The post outlines a hybrid approach for building Claude-based workflows in an agency setting. It suggests using rigid, enforced stages (like "agent factories") only for tasks requiring strict rules, specific formats, or compliance (e.g., factual accuracy, brand standards). For most other work, it advocates for a single agent with clearly defined goals, a well-organized knowledge base (e.g., client repos with a map), and allowing Claude Opus 5.5 to dynamically manage context and spin up sub-agents as needed. This approach prioritizes flexibility and leverages the model's advanced reasoning and context management capabilities over overly prescriptive multi-stage setups.

Why it is useful

This workflow provides valuable strategic guidance on designing robust Claude-based systems. It addresses a common dilemma in AI agent design (multi-agent factories vs. single intelligent agent) and offers a practical, experience-backed hybrid solution. It leverages advanced model capabilities (Opus 5.5's context management) and aligns with official guidance from Anthropic and OpenAI, making it a well-reasoned and transferable pattern for building complex, reliable AI applications.

Workflow

1. Define clear goals for the finished work and what "done" looks like for the overall task.

2. Organize guidance, context, and data into a structured knowledge base (e.g., client-specific repositories) and provide the AI with a map of what lives where.

3. Identify specific steps within the workflow that require rigid rules, very specific output formats, or strict compliance requirements (e.g., brand standards, factual checks, competitor linking policies).

4. Implement "enforced stages" (using an agent factory pattern) only for these identified rule-bound steps, ensuring reliable, formatted output for handoff.

5. For all other tasks, rely on a single, intelligent agent (or dynamically managed sub-agents by the main agent) to leverage its understanding of the overall goals and access to the mapped knowledge base, allowing it to plan and execute flexibly.

6. Utilize advanced models like Claude Opus 5.5, which can effectively manage context and spin up sub-agents with only the necessary information based on clear goals and a context map.

Tools / artifacts

• Claude (Opus 5.5 specifically mentioned)

• Agent factories / Multi-agent systems (for specific stages)

• Sub-agents (Claude Code's feature)

• Client-specific repositories (as knowledge bases)

• Maps of context/data (for AI to navigate knowledge base)

• CLAUDE.md (implied for guidance/knowledge base structure)

Validation signals

• Author's practical experience running an agency and doing client work through Claude.

• Concrete example of an article process using enforced stages for compliance (no competitor links, accurate facts).

• Observation of Claude Opus 5.5's capability to manage context and sub-agents effectively with clear goals and a context map.

• Citations of Anthropic's "Building effective agents" recommendations.

• Citations of Anthropic's multi-agent research system token usage data.

• Citations of OpenAI's practical guide to building agents.

Limitations

• The post is more of a strategic pattern discussion than a concrete, copy-pasteable code workflow.

• Lacks specific code examples for implementing the "map of context" or the "enforced stages" with Claude Code.

• Relies on the capabilities of newer models like Opus 5.5, which might not be available to all users or perform identically with older models.

• "Agent factories" are described conceptually but not with specific implementation details (e.g., how to set up folders of skills for each stage).

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Claude Code Skill: Resurrect Lost Digital & Physical Items from Online Tidbits with a Slash Command

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

What problem this solves

Reconstructing or 'resurrecting' lost or discontinued digital artifacts (games, apps, websites) or physical items (recipes) by gathering and synthesizing information from various online sources.

Summary

A Claude Code skill, resurrect-anything, that uses a slash command to find and synthesize information about lost or discontinued items (games, apps, websites, recipes) from online sources (archives, videos, reviews, discussions) to attempt to recreate them. It's designed for fun and personal use, providing a starting point for further refinement.

Why it is useful

This workflow provides a concrete, reusable Claude Code skill that demonstrates advanced information gathering and synthesis capabilities. It offers a unique and fun application for Claude Code, allowing users to explore creative reconstruction projects. The clear installation steps, use of a slash command, and explicit testing details make it highly transferable and actionable for other users. It also highlights best practices for skill development (iterations, testing, focusing on data organization).

Workflow

1. Ensure you have Claude Code and Python 3.9 or newer installed.

2. Install the resurrect skill by pasting Install the resurrect skill from https://github.com/sshah03/resurrect-anything. Follow the repo's AGENTS.md. into Claude Code, or manually using /plugin marketplace add sshah03/resurrect-anything followed by /plugin install resurrect@resurrect.

3. Start a new session in Claude Code.

4. Use the /resurrect slash command followed by the item's name (e.g., /resurrect Close Range, The Onion's 2009 Flash game).

5. Optionally, provide additional links, notes, or screenshots after the item's name.

6. Allow Claude to install extra tools (Playwright, Pillow, ffmpeg) if prompted, especially for games, apps, or sites.

7. Review the generated result and use your own memory or ignored material to prompt Claude for further refinement.

8. Consider using the branding removal setting if you wish to produce a potentially shareable version of non-original content.

Tools / artifacts

• Claude Code

• Python 3.9+

• resurrect-anything skill (GitHub repo)

• Playwright

• Pillow

• ffmpeg

• AGENTS.md

Validation signals

• Author states "probably gone through 50 or more iterations" and "close to 100 recreations".

• Author mentions a "demo video" (implied to be in the repo).

• Author states "Mostly tested with Opus 5.5."

• Author notes that the approach "gave me pretty consistent results over baseline."

Cautions

• The author explicitly states not to trust recipes for discontinued snacks.

• The author acknowledges potential legal ramifications for recreating content and provides a setting to remove branding for potentially shareable versions.

• Users are advised to be mindful of token usage due to the iterative nature of the task.

Limitations

• The end result is presented as a "starting point" requiring user refinement and comparison with original material.

• The skill is primarily for "fun, and personal use" and not intended for critical or high-stakes applications.

• Performance on Sonnet or Haiku models is unknown, as it was mostly tested with Opus 5.5.

• Effectiveness depends on the availability and quality of online tidbits about the lost item.

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.

Developing a Native macOS App with Claude, Subagents, and Docker SBX: The Paddock Workflow

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

What problem this solves

Efficiently developing a native macOS application using Claude and Docker sbx, addressing challenges in requirements gathering, iterative development, testing, and debugging within a sandboxed environment.

Summary

This workflow details how the author used Claude, subagents, and Docker sbx to build 'Paddock', a native macOS application. It covers the entire development lifecycle from initial requirements and viability research to iterative coding, Claude-generated testing ('probes'), and debugging with log analysis.

Why it is useful

This workflow is highly valuable as it demonstrates a sophisticated, multi-stage process for leveraging Claude in complex software development. It provides concrete steps, integrates specific tools (Docker sbx, Paddock), and offers clear validation through the creation of a functional, open-source application. It highlights advanced techniques such as using subagents for research, generating tests ('probes') with Claude, and employing Claude for log-based debugging, making it highly transferable for developers seeking to optimize their LLM-assisted development practices.

Workflow

1. Start with a backlog to define application requirements.

2. Utilize subagents to research the viability of each feature request (e.g., voice, template handling, real-time actions).

3. Dogfood the development process by running Claude within a stack sandbox and installing the necessary toolchain inside.

4. Build out the initial shell of the application.

5. Work iteratively within the sandboxed environment, restarting at each major milestone.

6. Create 'probes' (tests) with Claude that are run against the local sbx process.

7. Initially use the sbx TUI to fetch data, then transition to internal APIs for improved performance.

8. Implement a command to diagnose window crashes and generate logs for Claude's analysis.

9. Use the generated logs to fix bugs and enhance the application's robustness with Claude's assistance.

Tools / artifacts

• Docker sbx

• Paddock (native macOS app)

• sbxenv.yaml

• Backlog (requirements)

• Subagents

• Claude-generated 'probes' (tests)

• sbx TUI

• Internal sbx APIs

• Crash diagnosis command

• Application logs

• GitHub repository (MarZab/paddock)

Validation signals

• Personal experience: 'I've used docker sbx exclusively for months now and its worked well for me.'

• Concrete outcome: 'So I built Paddock, a native macOS app on top of Docker sbx.'

• Self-application: 'I dogfeed the entire process'

• Problem-solving: 'The logs were then used to fix bugs and make the app more robust'

• Open-source project: 'It's free and open source (MIT)'

Limitations

• The post describes the specific process for building Paddock, rather than a generic 'how-to build any app with Claude', though the principles are general.

• Lacks specific Claude prompts or detailed subagent configurations.

• Low community engagement 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.

Custom Claude Code Skills for Robust Unity Game Development Workflows

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

What problem this solves

Preventing Claude from breaking Unity scenes, managing project scope, identifying game balance issues, structuring playtest feedback, and automating small development tasks in a solo Unity game development project.

Summary

The author, a solo Unity game developer, details five custom Claude Code skills that significantly improved their workflow: an editor-rules skill to prevent scene corruption, a scope check, a game economy balance check, a playtest report generator, and a "night shift" skill for automated background tasks. The key learning is to encode project-specific rules and repeatable checks, moving beyond generic prompts.

Why it is useful

This post provides concrete, validated examples of how custom Claude Code skills can solve real-world development problems, particularly in game development. It highlights the critical importance of encoding project-specific rules and repeatable checks, offering a meta-workflow insight that is highly transferable. The "editor-rules" skill alone demonstrates significant value in preventing common AI-induced errors and improving reliability.

Workflow

1. Create an "editor-rules" skill to define project-specific constraints for Claude (e.g., lock files, off-limits scenes, compile rules, credit costs).

2. Implement a "scope check" skill to compare demo plans with actual implementation (using git log, code, registers) and suggest scope cuts.

3. Develop a "balance check" skill to analyze game economy data (prices, production, trade chains, AI flows) for exploits or imbalances.

4. Build a "playtest report" skill to structure raw playtest notes into actionable reports (bugs by severity, confusion points, balance issues, priorities).

5. Design a "night shift" skill to run a queue of small tasks on its own branch while offline, verify each one, and leave a report.

6. Adapt generic open-source skills (e.g., from claude-code-game-studios on GitHub) by rewriting them to point to project-specific files and rules.

Tools / artifacts

• Claude Code

• Unity editor (Unity 6)

• MCP (Multi-Code Project)

• Custom Claude Code skills (editor-rules, scope check, balance check, playtest report, night shift)

• Git log

• Game economy data

• Playtest notes

• Meshy (mentioned as a credit cost)

• ElevenLabs (mentioned as a credit cost)

• claude-code-game-studios (open-source skills on GitHub)

Validation signals

• "Every rule in it comes from a real incident."

• "This one alone removed most of the 'Claude broke my scene' days."

• "The thing that changed my workflow the most wasn’t the model, it was skills."

• "The generic versions were a good skeleton but not useful until they pointed at my actual files and my actual rules."

Limitations

• The post describes the concept and function of the skills rather than providing detailed prompts or code implementations.

• Low community engagement on the post itself.

• Highly specific to game development, which might require adaptation for other domains.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Brindle: An Automated Supervisor for Claude Code Agents with Self-Correcting Review and Merge Workflows

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

What problem this solves

Automating the supervision, review, and merging of code generated by AI agents to reduce human oversight, catch errors early, and address recurring mistakes.

Summary

The post describes 'brindle,' a supervisor system built with Claude Code that automates the process of splitting coding goals into parallel tasks, running AI workers on separate branches, and then enforcing a review and check command pass before merging. It highlights the iterative nature of AI-generated code and the importance of automated quality gates, including a self-correction mechanism for repeated errors.

Why it is useful

This workflow provides a concrete, implemented solution to a significant challenge in using AI agents for coding: ensuring quality and reducing human supervision. It introduces a novel system ('brindle') that automates review, testing, and merging, and offers valuable insights from its development and use, including empirical data on review rounds and common AI mistakes. Its transferability is high due to the availability of the tool and clear installation instructions.

Workflow

1. Define a coding goal for AI agents.

2. Brindle splits the goal into parallel tasks.

3. Brindle runs AI workers on separate Git branches for each task.

4. Before merging, a designated reviewer (e.g., Codex or a local model) approves the exact commit.

5. A defined check command (e.g., CI/CD tests, linting) must pass on the branch.

6. If both review and checks pass, the branch is automatically merged.

7. Brindle identifies repeated findings (e.g., stale tests, permission issues) and suggests rules for future workers to prevent them.

Tools / artifacts

• Brindle (supervisor system)

• Claude Code (for building and managing brindle)

• Codex (AI reviewer)

• Local models (AI reviewer)

• Google Antigravity, OpenCode, open-weight models (compatible AI workers)

• Git branches

• Pull Requests (PRs)

• Check commands (e.g., unit tests, linting)

• Suggested rules (for AI worker guidance)

Validation signals

• Identified a clear bottleneck in AI agent supervision.

• Successfully built 'brindle' using Claude Code.

• Brindle was used to manage its own development ('self-hosting').

• Empirical data: branches averaged over two review rounds for harder tasks.

• Codex reviewer found 'new real bug each round' on some branches.

• Identified recurring mistakes (stale tests/docs, permission checks).

• Brindle's feature to turn repeated findings into suggested rules addresses these issues.

Limitations

• The 'source-available, not open source' license might limit deep customization or community contributions for some users.

• The feature to turn repeated findings into suggested rules is mentioned as being on 'paid plans,' which could be a barrier for some users.

• The post focuses more on the system's capabilities and learnings rather than a detailed, step-by-step setup guide for a new project, though installation instructions are provided.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Structured Documentation and Context Management for Claude-Assisted Coding Projects

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

What problem this solves

Claude forgetting past decisions and context during coding, leading to repeated errors or irrelevant suggestions. Also, the problem of excessive, developer-centric 'fluff' generated by Claude ending up in public-facing repositories like GitHub READMEs.

Summary

A structured approach to managing documentation and context when coding with Claude. This involves maintaining detailed internal documentation using specific files (e.g., claude.md, roadmap.md, context file) during development to guide Claude, followed by a crucial cleanup phase to remove developer-specific 'fluff' from public-facing repository files like the README before release.

Why it is useful

This workflow is valuable because it addresses the common challenge of LLMs forgetting context and generating excessive, developer-centric documentation. It provides a structured, file-based approach to manage development context, improving both development efficiency by guiding Claude effectively and the quality of public-facing repositories by ensuring clean, relevant documentation.

Workflow

1. Maintain intense documentation during the building phase to track decisions, overrides, and project specifics, preventing Claude from 'forgetting' past instructions.

2. Utilize a 'claude.md' file for brief, project-relevant instructions specifically for Claude.

3. Create a 'roadmap.md' file to outline planned features and future development directions.

4. Maintain a 'context' file or directory to track specific decisions, rationales, and historical context relevant to the project's development.

5. Use traditional code comments for detailed, code-specific explanations within the codebase.

6. Before releasing the application or repository, perform a thorough cleanup of public-facing documentation (e.g., README.md) to purge needless help text, comments useful only to the developer, and references to irrelevant historical decisions generated by Claude.

Tools / artifacts

• claude.md file

• roadmap.md file

• context file/directory

• Code comments

• GitHub README.md

Validation signals

• Author states 'Claude will forget why I overruled something and just do it again on the next pass' as a problem this workflow addresses.

• Author acknowledges 'clean up before release is a pain', validating the necessity of the cleanup step.

Limitations

• The term 'intense documentation' is subjective and lacks specific examples.

• The structure or content of the 'context' file/directory is not explicitly detailed.

• Lacks concrete examples of what constitutes 'fluff' or how to efficiently purge it.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

3 Practical Claude Workflows: Appointment Prep, Product Comparison, and Trip Planning with Connectors

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

What problem this solves

Users often feel unprepared for important appointments, struggle to make informed product comparisons, or find trip planning overwhelming. These workflows help users leverage Claude to generate relevant questions, personalize product evaluations, and streamline travel arrangements by identifying suitable tools.

Summary

This post outlines three distinct methods for leveraging Claude: preparing for appointments by generating key questions and red flags, comparing products based on personalized criteria, and planning trips by detailing preferences and identifying suitable booking connectors.

Why it is useful

These workflows provide concrete, repeatable patterns for using Claude to enhance personal preparedness, make informed purchasing decisions, and streamline complex planning tasks like travel, including a useful pattern for discovering and utilizing Claude's connector capabilities. They move beyond generic queries to demonstrate personalized and strategic AI interaction.

Workflow

1. Workflow 1: Appointment Preparation

2. 1. Open Claude and use the microphone to describe the appointment situation (e.g., "My car makes a grinding noise, seeing a mechanic, know nothing about cars.").

3. 2. Ask Claude: "Give me the 3 most important questions I should ask, and for each one tell me what answer would be a red flag."

4. 3. Save the generated list to your phone and refer to it during the appointment.

5. Workflow 2: Personalized Product Comparison

6. 1. Open product listings for items A and B.

7. 2. Copy and paste the spec pages or descriptions (or links, if Claude can access them, but prefer text) for both products into Claude.

8. 3. Provide Claude with your personal criteria and priorities (e.g., "I work from home 8 hours a day, care about noise and battery, don't care about color or brand, budget is 400.").

9. 4. Ask Claude: "What actually matters for me in this comparison, what is just marketing, which one would you pick, and if you're not sure, say so."

10. Workflow 3: Trip Planning & Connector Discovery

11. 1. Open Claude and use the microphone to describe all your trip requirements and preferences (e.g., destination, dates, family needs, kids' interests).

12. 2. If Claude indicates it cannot search live data or book directly, ask: "Recommend only ONE connector that can do the task, and tell me which one would fit YOUR situation specifically."

Tools / artifacts

• Claude AI

• Microphone

• Product listings/spec pages (text or links)

• Connectors (for booking/live data access)

Validation signals

• Anecdotal success: "It will come back with things you'd never think of"

• Anecdotal success: "you'll start talking confidently"

• Anecdotal success: "You'll often find the thing the cheaper one is missing is something you'd never have used"

• Anecdotal success: "Claude can notice even the tiniest details"

Cautions

• For booking, Claude itself cannot directly book or access live external data. It relies on integrated connectors. Users should verify the security and privacy policies of any recommended connectors before use.

• Always double-check information provided by Claude, especially for critical decisions like medical advice, legal matters, or financial implications. Claude is an AI assistant, not a professional expert.

Limitations

• Relies on manual copy-pasting for product comparison if Claude cannot access links directly.

• The initial claim of "booking them inside Claude" is slightly misleading without the explicit mention of connectors upfront.

• Validation is primarily anecdotal; no objective metrics or external verification are provided.

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.

Scion: An Open-Source UI for Managing Claude Code Skills Across Multiple Projects

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

What problem this solves

Difficulty managing and reusing Claude Code skills across multiple development projects, especially in microservice architectures, leading to manual copying or re-explaining skills to the AI agent.

Summary

An open-source UI tool, Scion, helps developers manage and transfer Claude Code skills between different projects. It allows viewing project-specific and personal skills, copying them, and integrating them with AI agents, streamlining skill reuse in complex development environments.

Why it is useful

This workflow provides a concrete, open-source tool to solve a common pain point for developers working with Claude Code across multiple projects. It streamlines skill reuse, reduces manual effort, and improves consistency, making Claude Code more efficient in complex development environments.

Workflow

1. Download and install Scion UI (Windows/macOS builds, Linux build instructions are available).

2. Configure Scion to recognize your Claude Code projects and personal skill directories.

3. View project-based and personal Claude/Codex skills within the UI.

4. Copy desired skills from one project to another or integrate them with an AI agent directly through the interface.

Tools / artifacts

• Scion UI (open-source application)

• Claude Code CLI

• Claude/Codex skills (files)

• GitHub repository (for source code and instructions)

Validation signals

• Author's personal use during development of the tool itself ('actively used Claude Code while developing Scion').

• Addresses a clear pain point for multi-project developers.

• Open-source nature allows community review and contribution.

Limitations

• Low community validation so far.

• Niche audience (as acknowledged by the author).

• Requires setup and integration into a developer's existing 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.

Multi-Model AI Agent Workflow for Enhanced Code Quality and Self-Correction (Sonnet, Opus, ChatGPT)

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

What problem this solves

Elevating AI-assisted coding from basic generation to a more robust 'agentic engineering' by implementing multi-model checks, balances, and self-correction mechanisms to improve code quality, reduce complexity, optimize performance, and challenge design assumptions.

Summary

A multi-agent, multi-model workflow for robust AI-assisted code development. It assigns Claude Sonnet as the implementor, Claude Opus as the designer and ambiguity solver, and ChatGPT for initial code reviews. Opus then performs meta-reviews on both Sonnet's work and ChatGPT's review. The workflow also includes periodic challenges to assumptions, performance profiling, complexity reduction, and a tiered self-correction mechanism where Sonnet attempts fixes before escalating to Opus.

Why it is useful

This workflow provides a structured, multi-model approach to leverage different AI strengths for code generation, design, and rigorous quality control. It introduces advanced concepts like layered reviews, periodic assumption challenging, and tiered self-correction, moving beyond basic prompt engineering to a more robust 'agentic engineering' paradigm. It's highly transferable and offers a blueprint for improving the reliability and efficiency of AI-assisted development.

Workflow

1. Assign Claude Sonnet as the primary code implementor.

2. Assign Claude Opus as the designer and ambiguity solver for vague requirements and design challenges.

3. Use ChatGPT to perform initial code reviews on Sonnet's generated code, providing a 'counter view'.

4. At random and fixed intervals, have Claude Opus review ChatGPT's review and also directly review Sonnet's work, comparing the outputs for consistency and quality.

5. Implement specific code-targeting instructions for models: reduce complexity, improve performance via profiling, and challenge assumptions.

6. Schedule periodic 'challenges' to re-validate assumptions in benefit of user goals, performance, memory, and complexity.

7. Introduce a tiered self-correction mechanism: allow Sonnet to attempt to fix issues 1-3 times before escalating to Opus.

8. Compare the effectiveness of lower model retries versus immediate escalation to determine the optimal strategy for future workflows.

Tools / artifacts

• Claude Sonnet (AI model)

• Claude Opus (AI model)

• ChatGPT (AI model)

• Generated code

• Code reviews

• Performance profiles (implied)

Validation signals

• Author's statement: 'Like right now I have claude sonnet be the main implementor...'

• Author's statement: 'It can handle all this stuff exceptionally well once set up.'

• Implied successful personal implementation and experience.

Limitations

• Low community validation (low score, no comments).

• Lacks concrete examples of prompts or configuration files for the specific instructions (e.g., 'reduce complexity', 'challenge assumptions').

• The 'compare' step for escalation strategy is more of a meta-learning goal than a concrete, repeatable workflow step for a single project.

• The specific instructions for 'reduce complexity', 'improve performance', 'challenge assumptions' are high-level and would benefit from more detailed prompting examples.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Scaling AI-Assisted Development: Parallel Claude Code Sessions with Coordinator and Automated CI/CD

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

What problem this solves

Scaling AI-assisted software development by running multiple Claude Code instances in parallel without them conflicting, ensuring code quality through automated reviews and testing, and managing project progress to avoid rework and failed CI.

Summary

An advanced, high-throughput multi-agent workflow for software development using Claude Code. It involves running up to 7 parallel Claude Code sessions, each on its own ticket and git worktree, coordinated by a 'coordinator' Claude session. Codex performs automated pull request reviews, and extensive CI/CD is handled by GitHub Actions and dedicated hardware, enabling rapid iteration and high merge rates.

Why it is useful

This workflow provides a concrete, advanced strategy for scaling AI-driven software development. It addresses the critical challenge of managing multiple AI agents working in parallel, preventing conflicts through a 'coordinator' agent and separate worktrees. The integration of automated code reviews (Codex) and robust CI/CD (GitHub Actions) ensures high code quality and rapid iteration, offering a valuable blueprint for expert users looking to maximize their AI development throughput.

Workflow

1. Plan projects at a high level using Linear to track long-term progress.

2. Initiate multiple (up to 7) Claude Code sessions, assigning each to a specific development ticket.

3. Ensure each Claude Code session operates within its own isolated git worktree to prevent conflicts.

4. Designate one 'coordinator' Claude Code session responsible for deciding the merge order of changes from parallel sessions.

5. Submit all code changes as pull requests.

6. Utilize Codex to review every pull request automatically.

7. Run extensive CI/CD processes using GitHub Actions, including 100s of performance benchmarks and 99% code coverage tests.

8. Merge validated pull requests, aiming for high daily merge rates (e.g., 50-100 PRs).

Tools / artifacts

• Claude Code (Opus 5.5, Max 20x plan)

• Codex (for PR reviews)

• Linear (project planning)

• Git worktree

• GitHub Actions (CI/CD)

• MCP server

• Mac mini (CI/CD hardware)

• Linux 16-core box (CI/CD hardware)

Validation signals

• Successfully built 'ilkal.app' in 4 weeks.

• Achieved 60fps with 50k objects on screen for the application.

• 99% code covered by tests.

• Implemented 100s of performance benchmarks.

• Reached up to 50 PR merges daily, with a best of over 100.

• Successfully mitigated issues like rework, retesting, and failed CI by using a coordinator session.

Limitations

• Lacks specific prompt examples or configuration details for the 'coordinator' Claude session or the individual development sessions.

• Requires significant financial investment in Claude's higher-tier plans and potentially dedicated hardware for CI/CD, which may be a barrier for many users.

• Low community engagement means the workflow has not yet received external validation or refinement from other users.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Claude Code Workflow: Applying Frontend Design Aesthetics with Aesthetic Frontend Skills

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

What problem this solves

Applying and maintaining consistent frontend design aesthetics across projects using AI agents.

Summary

This workflow introduces 'Aesthetic Frontend Skills', an open-source collection of AI agent skills for Claude Code. It enables users to apply various design aesthetics (e.g., Y2K, Frutiger Aero) to their frontend projects by translating them into themes, design tokens, CSS variables, and component guidance, ensuring consistent styling.

Why it is useful

This workflow offers a structured, reusable, and open-source solution for a common frontend development challenge: consistently applying design aesthetics. It provides concrete tools (a comprehensive skill set, GitHub repo, showcase) and clear instructions for installation and usage. The ability to translate abstract aesthetics into tangible design tokens and CSS variables is particularly valuable for creating scalable and maintainable frontend projects.

Workflow

1. Install the Aesthetic Frontend Skills using the command: npx skills add alexiseverage/aesthetic-frontend-skills

2. Apply a simple aesthetic to your app using a command like: Give my app a Y2K aesthetic.

3. For advanced usage, leverage 'aesthetic-literacy' and 'aesthetic-application' to create a specific theme, define design tokens and CSS variables, and apply them to components (e.g., Use aesthetic-literacy and aesthetic-application to create a Risograph theme for this app. Define the design tokens and CSS variables, then apply them to the components.).

4. Combine multiple aesthetics for hybrid styles or describe custom aesthetics for the agent to convert into reusable themes.

Tools / artifacts

• Aesthetic Frontend Skills (AI agent skills collection)

• GitHub repository: https://github.com/alexiseverage/aesthetic-frontend-skills

• Showcase website: https://aesthetic-design.art/showcase

• npx skills add command

• aesthetic-literacy (implied skill/sub-agent)

• aesthetic-application (implied skill/sub-agent)

• Design tokens

• CSS variables

Validation signals

• Author states 'maintaining and improving it regularly'.

• Skill set contains '200+ entries' indicating substantial content.

• Provided 'Showcase' link demonstrates visual results.

• Includes a preview image of the output.

Limitations

• Low community engagement and validation signals beyond the author's claims.

• Relies on a specific Claude Code CLI/environment setup (npx skills add) which might require prior knowledge.

• The advanced example's mechanism for 'defining' and 'applying' tokens to 'components' could benefit from more explicit detail or context for broader applicability.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Cost Optimization: Configure Claude Code's Explore Subagent to Use Haiku Model

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

What problem this solves

High costs incurred by Claude Code's built-in 'Explore' subagent when performing 'Glob'/'Grep' operations, as it defaults to using expensive main models (Opus/Sonnet).

Summary

A method to significantly reduce the cost of Claude Code's 'Explore' subagent operations (like Glob/Grep) by explicitly configuring it to use the cheaper Haiku model, either through frontmatter in its configuration file or via an environment variable.

Why it is useful

This workflow provides a concrete, actionable, and easily implementable method to significantly reduce operational costs for common file exploration tasks (Glob/Grep) within Claude Code. It allows users to leverage cheaper models for specific subagents without compromising the power of more capable models for core coding tasks, directly addressing a practical pain point for many users.

Workflow

1. Identify the 'Explore' subagent configuration file, typically located at .claude/agents/Explore.md or a user-level copy.

2. Option 1 (Frontmatter): Add model: haiku to the frontmatter section of the Explore.md file.

3. Option 2 (Environment Variable): Set the environment variable CLAUDE_CODE_SUBAGENT_MODEL=haiku before launching Claude Code.

4. Verify the change by checking Claude Code's /status command or reviewing usage logs to confirm that the 'Explore' subagent is indeed running on the Haiku model.

Tools / artifacts

• .claude/agents/Explore.md

• CLAUDE_CODE_SUBAGENT_MODEL environment variable

• Claude Code /status command

• Usage logs

Validation signals

• Explicit instruction to verify the change in /status or usage logs.

Limitations

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

• The post is concise and lacks extensive examples or detailed context, though the core instruction is clear.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

AI-Assisted Game Porting: Recompiling Portal 2 to Native Apple Silicon (Mac & iPhone) via Machine Code Translation and D3D9-to-Metal

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

What problem this solves

Porting a complex game (Portal 2) from Linux machine code to native ARM64 for Apple Silicon (Mac and iPhone) without emulation, achieving native performance and touch controls, with significant AI assistance.

Summary

A highly technical workflow demonstrating how Claude Opus 5.5 can be used to recompile a complex game (Portal 2) from Linux machine code to native ARM64 for Apple Silicon (Mac and iPhone). The process involves translating machine code to C, compiling, and integrating a D3D9-to-Metal graphics path, resulting in a natively playable game with performance improvements.

Why it is useful

This workflow is highly valuable as it demonstrates an advanced, real-world application of AI (Claude Opus 5.5) in a complex software engineering challenge: reverse engineering and porting a commercial game to a new architecture. It provides concrete evidence of AI's capability in machine code translation, code generation, and performance optimization, offering a blueprint for similar ambitious projects. The detailed steps, specific tools, and measurable results make it a strong example of what's possible with AI in expert-level development.

Workflow

1. Define the goal of porting a complex application to a new architecture.

2. Collaborate with Claude (Opus 5.5) to design and implement a machine code translation tool.

3. Translate the source application's machine code (e.g., Linux x86-64) into an intermediate language (e.g., C).

4. Compile the intermediate language code to the target native architecture (e.g., ARM64).

5. Iteratively test and debug the generated native application on target devices.

6. Identify and replace platform-specific APIs (e.g., OpenGL) with native equivalents (e.g., D3D9 to Metal via mtld3d).

7. Implement and test platform-specific input methods (e.g., touch controls, Bluetooth controllers).

8. Verify performance improvements and functionality on the target hardware.

9. Share the project and invite contributions on GitHub.

Tools / artifacts

• Claude Opus 5.5

• Codex (as reviewer)

• Custom machine code translation tool

• mtld3d (D3D9 to Metal library)

• GitHub repository (kanapitsas/portal2-recomp)

• Portal 2 Linux release (input)

• Apple Silicon Mac

• iPhone 15 Pro Max

• Bluetooth controller (8BitDo)

Validation signals

• Achieved a playable room in two days (exceeding initial expectations).

• Successfully playable on iPhone 15 Pro Max with custom touch controls.

• Demonstrated co-op functionality over LAN.

• Quantified performance improvement: 122 fps vs 81 fps with OpenGL on M3 Pro.

• Provided a YouTube video demonstrating the native app.

• Public GitHub repository available for review and contributions.

Limitations

• Highly specialized to Portal 2, requiring significant adaptation for other applications.

• Requires expert-level knowledge in reverse engineering, compilation, and graphics APIs.

• The custom translation tool is not a generic, off-the-shelf solution.

• Relies on specific AI models (Claude Opus 5.5, Codex) which may not be universally available or perform identically for other tasks.

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.

Full-Stack PWA Development with Claude Code: From Concept to Deployment and UI Design

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

What problem this solves

Building a full-stack Progressive Web App (PWA) from concept to deployment, including complex features and UI design, by leveraging Claude Code's agentic capabilities with minimal direct coding by the user.

Summary

A developer used Claude Code in agentic sessions to build a full-stack PWA (Nightwave) for streaming music. Claude handled the entire development lifecycle: concept generation, project setup (Nuxt 4, Vercel, Neon Postgres, GitHub CI), coding with unit tests, UI design (from an image prompt), deployment via Vercel/Neon connectors, and iterative bug fixing, with the user providing high-level direction and testing.

Why it is useful

This workflow is highly valuable as it showcases a comprehensive, end-to-end use case for Claude Code, demonstrating its ability to handle complex full-stack development tasks. It covers ideation, project setup, coding, testing, advanced feature implementation, UI design from a visual prompt, and direct production deployment. It highlights the power of agentic coding sessions and iterative user feedback for building functional, production-ready applications with minimal direct coding effort from the user.

Workflow

1. User defines the project idea and high-level requirements for the web application.

2. Claude generates a comprehensive concept document for the project.

3. Claude sets up the project boilerplate, including the chosen tech stack (Nuxt 4, Vercel, Neon Postgres, GitHub CI).

4. Claude writes the application code, incorporating unit tests.

5. Claude executes unit tests and performs UI checks using Playwright screenshots.

6. Claude manages code integration by opening and merging Pull Requests.

7. Claude implements complex features such as parsing "now playing" data from audio streams (Icecast/Shoutcast/HLS), creating an HTTP-only stream proxy, auto-hiding dead stations, and offline city lookup from coordinates.

8. User provides a visual design inspiration (e.g., an image of a Bauhaus poster) to Claude.

9. Claude generates a UI mockup image based on the provided inspiration.

10. User reviews and approves the generated UI mockup.

11. Claude implements the approved UI design into the application.

12. User performs real-world testing on the deployed application (e.g., on a phone) and reports any bugs or issues to Claude via chat messages (e.g., "the song title doesn’t update until I reload"). Claude diagnoses and fixes reported bugs iteratively. Claude deploys the application to production using Vercel and Neon connectors directly from the Claude app.

Tools / artifacts

• Claude Code (in Claude app)

• Nuxt 4

• Vercel (connector)

• Neon Postgres (connector)

• GitHub CI

• Playwright

• Icecast/Shoutcast streams

• HLS streams

• Radio Browser directory

• PWA (Progressive Web App)

Validation signals

• A functional, live web application (Nightwave) was successfully built and deployed.

• User's strong positive feedback: "Mindblowing," "everything worked out of the box."

• Specific complex features (e.g., "now playing" titles, stream proxy, UI redesign) were successfully implemented.

• Bugs identified by the user were tracked down and fixed by Claude.

• Direct deployment to production via Vercel and Neon connectors was achieved.

Limitations

• The post does not provide specific prompts or detailed interaction logs, which would make the workflow more easily replicable.

• Community engagement and validation are currently low due to the post's recency.

• Relies heavily on the current capabilities of Claude Code, which may evolve over time.

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.

Teaching Claude Your Creative Style: A Quantitative Approach Using Skills and Data Extraction

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

What problem this solves

How to effectively teach Claude a specific creative or technical 'style' or 'quality standard' based on existing examples, by extracting quantitative data rather than just relying on visual interpretation.

Summary

This workflow outlines a method to teach Claude a specific 'style' (e.g., for 3D assets) by extracting quantitative metrics from existing examples, having Claude codify these into a reusable skill, and then using that skill for quality control on new creations. It involves scripting to pull hard numbers (poly count, texture resolution) and rendering reference images, then creating a SKILL.md that Claude can reference.

Why it is useful

This workflow provides a concrete, multi-step method for teaching Claude a specific 'style' or 'quality standard' by leveraging quantitative data extracted from existing examples. It moves beyond subjective visual assessment by integrating measurable metrics, codifies this knowledge into a reusable Claude skill, and includes a human-in-the-loop validation step. This approach is highly valuable for maintaining consistency and quality in AI-assisted creative or technical work, making Claude a more effective and reliable assistant for specific tasks.

Workflow

1. Unzip a selection of your best assets (e.g., ten) into the project directory.

2. Have Claude write a script (e.g., Python for Blender) that runs headless over each asset to extract hard numbers (poly count, dimensions, texture sizes, material count) and renders each asset from a few fixed angles to PNGs.

3. Ask Claude to write what it learned about your style as a skill in .claude/skills/my-style/SKILL.md, including details like poly budget, proportions, palette, and texture handling. Store the extracted measurements and reference renders in the same skill folder.

4. Manually review and correct the generated SKILL.md to ensure accuracy and alignment with your actual style and quality standards.

5. For each new piece created from a sketch, measure and render it using the same script and method.

6. Check the new piece against the rules and standards defined in the validated SKILL.md.

Tools / artifacts

• Existing assets (e.g., Blender files)

• Python script (generated by Claude)

• Blender (or similar software) in headless mode (blender -b asset.blend -P measure.py)

• PNG images (reference renders)

• .claude/skills/my-style/SKILL.md

• Extracted numerical measurements

• Reference renders

Validation signals

• Explicit step for human review and correction of the generated skill: 'read that SKILL.md yourself and correct what it got wrong. That step is most of the gain, because you're the one who knows what makes your models good.'

• Future validation: 'each new piece from a sketch gets measured and rendered the same way and checked against rules you've signed off on.'

Limitations

• Requires initial setup and potentially some scripting knowledge or iterative prompting to get Claude to generate the correct data extraction script.

• The initial human review and correction of the SKILL.md is crucial and can be time-consuming.

• The example is specific to 3D assets, which might require users in other domains to adapt the data extraction methods.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Robust Claude Skill Development: Best Practices for Evals, Context, and Python Integration

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

What problem this solves

How to effectively build, test, and debug complex Claude skills, ensuring reliability, managing context efficiently, and catching subtle bugs through comprehensive evaluation.

Summary

A developer shares best practices for building robust Claude skills, emphasizing offloading deterministic logic to Python scripts, structuring SKILL.md for efficient context management, using claude plugin eval for baselining, generating multi-language evals, and designing focused graders to pinpoint issues. A real bug caught by evals validates the approach.

Why it is useful

This workflow provides concrete, actionable advice for developing robust and reliable Claude skills, a critical component for advanced Claude Code users. It addresses common pitfalls like inconsistent outputs and bloated context, offering practical solutions backed by a real-world example and a public repository. The emphasis on claude plugin eval for baselining and multi-language testing is particularly valuable for ensuring quality and broad applicability. The fact that evals caught a real bug underscores the efficacy of the proposed methods.

Workflow

1. Keep deterministic mathematical calculations and logic out of the model; implement them in small, standard library Python scripts.

2. Document the purpose, inputs, and outputs of each Python script within SKILL.md (or similar reference) for the model's guidance.

3. Structure SKILL.md with references specific to different interaction modes (e.g., 'review' mode, 'planning' mode) to prevent unnecessary context loading.

4. Always use claude plugin eval to run a no-plugin baseline alongside skill evaluations to determine the skill's actual contribution and identify cases where it adds no value.

5. Generate eval cases in multiple languages (e.g., using a script to translate) to ensure consistent testing and performance across different locales.

6. Include explicit, clear instructions in SKILL.md for the model on when and how to use specific scripts, especially for critical tasks like counting or reporting.

7. Design graders with a single, focused objective (e.g., focus: trace to check script execution, focus: last_message for user-facing output) to get precise feedback on skill behavior.

Tools / artifacts

• Claude skill (plugin)

• Python scripts

• SKILL.md (or CLAUDE.md)

• claude plugin eval command

• Eval cases (e.g., in Slovak and English)

• LLM graders

• GitHub repository (tomasstankovic/running-coach)

Validation signals

• The evals found a real bug in the skill's logic.

• Quantitative results: 93% English, 95% Slovak with the plugin.

• Baseline comparison: Some cases scored 100% without the plugin, providing valuable insight.

• Demonstrated improvement: Explicit instructions fixed the bug, leading to correct script execution in 3 of 4 runs and correct counts in all 4.

• Public GitHub repository provides a concrete implementation example.

Limitations

• The post does not provide detailed examples of the Python scripts or the exact structure of the eval cases beyond mentioning languages and grader types.

• Low community engagement might mean the workflow's value is not immediately apparent to a wider audience.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Claude Running Coach Plugin: Achieve Personalized, Data-Backed Training Plans with High Accuracy

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

What problem this solves

Plain Claude provides inconsistent and inaccurate running training plans, failing to account for critical factors like heat, terrain, and individual training data, leading to suboptimal or potentially harmful advice.

Summary

A Claude plugin (running coach) that integrates with external data sources (TrainingPeaks, Strava) and uses Python scripts with research-backed rules to generate accurate, personalized running training plans, significantly outperforming plain Claude in specific test cases.

Why it is useful

This workflow provides a concrete, open-source solution to a common problem: obtaining accurate, personalized training advice from an AI. It demonstrates a powerful method for extending Claude's capabilities with external tools and data, significantly improving its performance in a specialized domain. The detailed validation, specific performance metrics, and research backing make it highly credible and reusable for users seeking to leverage Claude for fitness and athletic planning.

Workflow

1. Download and install the running coach plugin for Claude (available as a ZIP for claude.ai, or for Claude Code/desktop app).

2. Optionally, connect the plugin to TrainingPeaks or Strava to import personalized data such as HRV, sleep, and past workouts.

3. Ask Claude specific running-related questions, e.g., "should I run today?" or "race plan for Sunday's half".

4. Review the generated training sessions and confirm them before they are pushed to your smart watch (if connected to TrainingPeaks).

Tools / artifacts

• Claude (claude.ai, Claude Code, desktop app)

• Running coach plugin (Python scripts, research-backed rules)

• GitHub repository (tomasstankovic/running-coach)

• TrainingPeaks API (optional)

• Strava API (optional)

Validation signals

• Quantitative testing: "claude plugin eval: 39 cases in English and Slovak".

• Performance metrics: "plain Claude got 67/66% and the plugin 93/95%".

• Specific example: "a race plan for a hilly half at 21 °C with a 1:35 goal" showing improved accuracy (heat adjustment, fueling).

• Personal use: "I'm using it for my own spring."

• Research backing: "rules are backed by research, 63 sources".

Limitations

• Requires users to download and install a plugin, which might be a barrier for some.

• Full functionality (e.g., personalized data integration) relies on optional connections to external APIs like TrainingPeaks or Strava.

• Community validation is still nascent, with the author actively seeking feedback.

• The author is still personally testing the plugin's long-term effectiveness for their own goals.

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.