r/ClaudeWorkflows • • 2h ago

Selected Workflow [Workflow] Use a reference implementation as a test oracle for Claude Code

1 Upvotes

Use a reference implementation as a test oracle for Claude Code

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

What problem this solves

Improving the accuracy of a complex implementation when documentation alone is insufficient and small behavioral differences cause failures.

Summary

Implement isolated components in human-approved phases, then use an established reference implementation to generate expected outputs and drive repeated test-and-fix cycles with Claude Code.

Why it is useful

It describes a repeatable, evidence-backed development loop in which tests and reference behavior constrain Claude’s fixes, rather than relying on generated code or incomplete documentation alone.

Workflow

  1. Define an integration milestone that requires several core components to work together.
  2. Isolate components so Claude can work on a limited portion of the code at a time.
  3. Create a phased action plan for each component, review and approve it, then implement and review the changes.
  4. Use strict component-level tests, such as single-step processor tests, during implementation.
  5. Build a trusted reference implementation locally and generate reference outputs for a relevant test suite.
  6. Run the implementation against those outputs, have Claude investigate and fix behavioral differences, and repeat.
  7. Keep the resulting suite as a regression test and provide precise human direction for usability decisions.

Tools / artifacts

Validation signals

  • The author reports reaching the Kickstart insert-disk screen and later running a game cracktro, initially with glitches.
  • The author reports that reference-output comparisons let Claude fix behavioral differences and were the turning point for accuracy.
  • The full resulting regression suite reportedly takes about five hours to run.
  • The author links a public project and reports a version 0.8.0 release.

Cautions

  • A reference implementation can also contain defects; verify important expectations against specifications or additional independent references.
  • Respect licensing and distribution restrictions for emulator ROMs, test media, and generated fixtures.

Limitations

  • No exact build commands, prompts, test invocation, or output-comparison procedure are provided.
  • Reported improvement is qualitative, with no before-and-after pass counts or independently verified accuracy claims.
  • The five-hour full suite may be costly to run frequently.

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 • • 2h ago

Selected Workflow [Workflow] Lead–worker Claude Code development with independent verification

1 Upvotes

Lead–worker Claude Code development with independent verification

Workflow value: 78/100
Status: active · Freshness: 70/100 · Confidence: 0.94 · Level: advanced
Categories: Quality Control, Token Saving, Debugging, Shipping, Hooks, Subagents, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Agent-written code can pass its own tests while still failing in real use, and benchmarks can be contaminated by unrelated plugins.

Summary

Use a lead Claude Code session to delegate changes to a worker, independently verify the results, and add adversarial review and real-environment checks before release.

Why it is useful

It combines a repeatable delegation pattern with independent test reruns, real-user checks, and concrete examples of defects and benchmark contamination that automated results alone missed.

Workflow

  1. Run a worker session in tmux and have a separate lead session write a task file for each change.
  2. Let the worker implement the change, then have the lead independently rerun typechecking and both test suites.
  3. Try the feature in a real terminal, including a fresh first-run experience, rather than relying on automated tests alone.
  4. Request independent reviews, including reviewers defending and attacking the implementation and a security review of untrusted inputs; turn findings into fixes.
  5. For prompt benchmarks, isolate settings sources and record individual runs; the author used --setting-sources project to exclude user settings.
  6. Bump the plugin version for each release so installed copies can receive updates.

Tools / artifacts

  • Claude Code sessions
  • tmux
  • Task files
  • Typechecker and test suites
  • Review agents
  • Real-terminal first-run check
  • --setting-sources project
  • bench/RESULTS.md

Validation signals

  • The author reports that a broken first-run redraw escaped passing tests and was discovered while recording a README demonstration.
  • The author reports that lead-session reruns and human screenshot inspection caught defects.
  • The author describes a benchmark with eight runs per arm after discovering that user-configured plugins contaminated earlier runs.

Cautions

  • Treat downloaded assets and other external inputs as untrusted during security review.
  • Use an isolated test environment for first-run checks rather than deleting existing user data.
  • Disclose model usage and any data sent externally before enabling such features.

Limitations

  • The post promotes its own plugin, although it provides a reusable development process.
  • It does not provide the task-file template, exact delegation commands, or review prompts.
  • Results are author-reported and lack independent community confirmation.
  • The benchmark finding is limited to the described task and settings; the isolated project configuration should still be inspected.

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 • • 5h ago

Selected Workflow [Workflow] Adapt and validate a scroll-driven GSAP site with Claude Code

1 Upvotes

Adapt and validate a scroll-driven GSAP site with Claude Code

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

What problem this solves

Build and adapt scroll-driven animated sites while checking that animations work across screen sizes and actual devices.

Summary

Use an open-source GSAP site as a template, preserve its scroll director and controls, adapt its content and visuals, and validate each change with production builds, browser checks, deliberate test failures, and real-device review.

Why it is useful

It combines a reusable adaptation prompt with a concrete animation architecture and a strong verification practice: deliberately proving that checks fail when the behavior is broken.

Workflow

  1. Choose a single visual concept and plan its scenes as a sequence measured in screens of scroll.
  2. Adapt a Sum, Meridian, or Datum site with Claude Code, explicitly listing what may change and preserving the scroll director, scene timing, buttons, arrow keys, and text-image separation rule.
  3. Keep text and numbers in content.ts and derive image-based measurements with scripts rather than entering them manually.
  4. Use paused GSAP timelines driven by scroll and sticky positioning for pinned scenes; adapt the visual assets to the concept.
  5. After each change, make a production build and run the site's checks at wide and phone-sized viewports. Review full-size frames of each resting scene.
  6. Deliberately break an animation rule and confirm that its check fails, then restore the implementation.
  7. Test on a real phone as well as in automated browsers, especially for animation and engine compatibility.

Tools / artifacts

  • Claude Code
  • GSAP
  • Puppeteer
  • CSS position: sticky
  • content.ts
  • Sum, Meridian, and Datum source code
  • Production builds and scene frames

Validation signals

  • The author reports browser checks covering scenes on desktop and phone-sized viewports.
  • A real iPhone reportedly exposed a GSAP scale-setting error that automated checks missed.
  • Deliberately breaking Datum revealed that its initial check passed even when lines were never drawn.

Cautions

  • Review third-party repository code and scripts before running them.
  • Check rights, privacy, and costs before uploading images to external generation or editing services.

Limitations

  • Results and test behavior are author-reported; no independent validation is provided.
  • The post does not provide exact build or check commands, or the implementation of the browser assertions.
  • The initial check failure illustrates that passing screenshots or assertions alone can miss incorrect motion.
  • The full approach requires substantial GSAP, browser-testing, and potentially WebGL expertise.

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 • • 10h ago

Selected Workflow [Workflow] Keep Claude's verification checks with CLAUDE.md rules and a bounded Stop hook

1 Upvotes

Keep Claude's verification checks with CLAUDE.md rules and a bounded Stop hook

Workflow value: 76/100
Status: active · Freshness: 70/100 · Confidence: 0.94 · Level: intermediate
Categories: Quality Control, Token Saving, Debugging, CLAUDE.md, Hooks
Original source: r/ClaudeCode post/comment

What problem this solves

Claude may verify a change with temporary scripts but leave few reusable tests in the repository.

Summary

Add verification requirements to CLAUDE.md and a bounded Stop hook that runs tests and asks Claude to fix failures. Encourage persistent property, differential, and performance tests rather than relying only on temporary checks.

Why it is useful

It provides a repeatable way to turn ephemeral verification into durable tests, with a concrete comparison and an explicit cost tradeoff.

Workflow

  1. Add project-specific verification rules to CLAUDE.md, including retaining useful checks as repository tests.
  2. Where appropriate, add property tests, differential tests against a preserved reference implementation, and performance tests.
  3. Configure a Stop hook to run the project verification script and return exit code 2 with a corrective message when tests fail.
  4. Check stop_hook_active to prevent repeated hook-triggered retries from looping indefinitely.
  5. Validate the setup by running representative checks and introducing a controlled defect to see whether the tests and hook catch it.

Tools / artifacts

  • CLAUDE.md verification section
  • Claude Code Stop hook
  • settings.json
  • verify.sh
  • Property, differential, and speed tests

Validation signals

  • The author reports that both the configured and plain runs passed a hidden grader using 3,000 random strings, 5,000 random orders, and 7 real files.
  • The configured run left 13 new tests in the repository, while the plain run left 4 small example tests and used temporary scripts for other checks.
  • A manually planted bug caused 4 of 16 tests to fail in the configured repository, versus 1 of 7 in the plain repository; the configured Stop hook returned exit code 2.
  • The reported configured run cost $0.55 and took 157 seconds, versus $0.35 and 104 seconds for the plain run.

Cautions

  • The bounded retry prevents an infinite loop but does not guarantee that every failing test is fixed before Claude stops; retain independent review and CI checks.
  • Review test failures rather than blindly changing either implementation or tests: tests themselves can be incorrect.
  • Inspect externally supplied hook scripts before running them and avoid verification commands with destructive side effects.

Limitations

  • The comparison used only one run per configuration on small Python tasks.
  • The defect was manually planted rather than introduced during a subsequent Claude session.
  • The exact five rules and hook implementation are not present in the post itself.
  • The measured outcome supports better retained regression coverage, not superior correctness on the original task.

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 • • 10h ago

Selected Workflow [Workflow] Audit Git hooks configuration after launching worktree-isolated subagents

1 Upvotes

Audit Git hooks configuration after launching worktree-isolated subagents

Workflow value: 76/100
Status: active · Freshness: 70/100 · Confidence: 0.93 · Level: intermediate
Categories: Quality Control, Debugging, CLAUDE.md, Hooks, Skills, Subagents, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Detect and mitigate a reported Claude Code worktree-subagent behavior that rewrites a repository's shared Git hooks configuration.

Summary

Compare the Git hooks path and config modification time before and after launching a worktree-isolated subagent, then avoid that isolation mode or enforce policy and verification gates if the issue reproduces.

Why it is useful

Provides a repeatable, narrowly scoped diagnostic for a potentially consequential configuration change, with practical mitigation and verification options.

Workflow

  1. In a disposable clone, record git config --show-origin --get core.hooksPath and the modification time of the main checkout's .git/config.
  2. Launch a no-op subagent with isolation: "worktree", then repeat the checks. Look for a relative hooks path changing to an absolute path.
  3. If affected, avoid automatic worktree isolation; create a worktree manually or use a disposable clone for reviews.
  4. Consider a PreToolUse policy that denies worktree-isolated Agent calls and relevant Bash configuration writes.
  5. Check the expected hooks path and actual hook behavior before push or merge; use an independent CI merge gate where possible.

Tools / artifacts

  • git config --show-origin --get core.hooksPath
  • stat on .git/config
  • git worktree add
  • git clone --no-hardlinks
  • PreToolUse hook
  • core.hooksPath

Validation signals

  • Author reports repeated config rewrites, including with a no-op subagent in a throwaway clone.
  • Author reports inspecting the relevant behavior in the Claude Code 2.1.321 binary.
  • The post provides before-and-after checks that readers can use to test their own installations.

Cautions

  • Test in a disposable clone and preserve existing Git configuration.
  • The .git/config stat commands assume a main checkout; linked worktrees generally have a .git file instead.
  • A manually created worktree still shares repository configuration; avoid subsequently invoking the affected automatic isolation mode.
  • A PreToolUse command filter needs careful implementation and should not be treated as a complete security boundary. A pre-push hook alone cannot enforce a gate if the hooks path is broken.

Limitations

  • The claimed behavior is version-specific and has not been independently confirmed in the supplied material.
  • The post does not provide an implementation for the proposed denial hook or CI gate.
  • Husky exposure and missing-hook-directory behavior are identified as untested.
  • A changed path and modification time are useful indicators but do not by themselves prove which process made the change.

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 • • 10h ago

Selected Workflow [Workflow] Preserve decision rationale across compaction with decision records and handoffs

1 Upvotes

Preserve decision rationale across compaction with decision records and handoffs

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

What problem this solves

Long Claude Code sessions can lose the reasons behind decisions and negative constraints during context compaction, causing deliberate choices to be revisited or undone.

Summary

Preserve decision rationale and constraints both in guided compaction instructions and in persistent project files. For long tasks, review a written handoff before clearing the session and starting with fresh context.

Why it is useful

It provides a concrete, repeatable way to carry intent across context resets, including a human verification gate and durable artifacts. Its main limitation is the lack of independent validation.

Workflow

  1. Record significant choices in a decisions file using a concise format: choice, rejected alternative, reason, and conditions for revisiting.
  2. Add brief code comments near non-obvious deliberate behavior pointing to the relevant decision.
  3. Before automatic compaction, run /compact with instructions to retain decision rationales and exact negative constraints; optionally document compaction priorities in CLAUDE.md.
  4. For a longer task, ask Claude to write a handoff file covering the goal, decisions and reasons, constraints, and next step.
  5. Read and correct the handoff before using /clear, then instruct the fresh session to read the file.

Tools / artifacts

  • /compact
  • /clear
  • CLAUDE.md
  • decisions.md
  • Handoff file
  • Code comments

Validation signals

  • The author anecdotally reports that a nearby comment pointing to the decisions file helps prevent deliberate behavior from being changed.
  • The handoff workflow includes a human review step to catch drift before clearing context.

Cautions

  • Review the handoff for completeness before /clear; unsaved conversational context may otherwise be lost.
  • Do not rely on compaction instructions to preserve every constraint exactly; verify critical requirements in persistent files.
  • Avoid putting secrets or sensitive information into decision or handoff files that may be committed or shared.

Limitations

  • The effectiveness claims are anecdotal, with no controlled comparison or detailed success report.
  • The comment does not provide a complete handoff template or an automated check that decisions are followed.
  • Keeping decision files current requires ongoing manual discipline.

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 • • 10h ago

Selected Workflow [Workflow] Repository handoffs and review gates for a stateless asset-making agent

2 Upvotes

Repository handoffs and review gates for a stateless asset-making agent

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

What problem this solves

Give a stateless asset-making agent consistent project knowledge and review criteria without relying on session memory or duplicating decisions across documents.

Summary

Organize versioned repository documents by ownership, use a root handoff to select required reading, and run each asset through a documented creation and human-review process.

Why it is useful

It provides a concrete, adaptable way to give agents scoped project knowledge and evaluate creative output against documented standards and approved examples, while keeping a human decision gate.

Workflow

  1. Create a root handoff that maps work types to the documents agents should read.
  2. Maintain short repository-wide rules in AGENTS.md, including safety, architectural boundaries, and work-landing conventions.
  3. Separate the model-making method, art direction, decision register, specifications, budgets, shared-library guidance, and engine asset contract into owned documents.
  4. For every task, read the repository rules, model method, art direction, and issue; load other documents as the brief requires.
  5. Consult approved models, review notes, and captures as concrete quality references, and read earlier attempts for functional requirements rather than copying their implementation.
  6. Follow the model method: brief and written design, build in code, inspect each round, integrate into the game, and obtain independent review and a blind lineup.
  7. Require a human verdict before landing, and keep the model README status and relevant decision records current.

Tools / artifacts

  • AGENTS.md
  • Root handoff file
  • model-method.md
  • art-direction.md
  • Domain decision register and index
  • Building specification cards
  • model-budgets.md
  • Shared materials and goods library READMEs
  • Engine asset contract
  • Reference model source, review notes, and captures
  • Task issue and model README

Validation signals

  • The described process calls for inspection at fixed camera distances and comparison against approved reference models.
  • It includes independent review, a blind lineup, and a human verdict before landing.
  • The comment describes an established document structure and task-specific reading rules, but reports no measured outcomes or completed example.

Cautions

  • The stated repository rules prohibit committing secrets or writing to real player save folders during tests.
  • Independent review and a human landing decision provide oversight, although the comment does not specify how review independence is enforced.

Limitations

  • No repository, document templates, or runnable implementation is provided.
  • No before-and-after result, test evidence, or community success report is supplied.
  • The blind-lineup procedure and enforcement of document freshness and ownership are not specified.
  • The workflow is not explicitly Claude-specific; AGENTS.md may need adaptation to the user's Claude Code setup.

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

Selected Workflow [Workflow] Test protected-path hooks across Bash and editing tools

2 Upvotes

Test protected-path hooks across Bash and editing tools

Workflow value: 75/100
Status: active · Freshness: 70/100 · Confidence: 0.93 · Level: advanced
Categories: Quality Control, Debugging, Hooks
Original source: r/ClaudeCode post/comment

What problem this solves

A Claude Code path guard blocked Edit and Write but allowed the same protected-file change through Bash.

Summary

Extend a protected-path hook to cover obvious Bash mutations, test hook decisions with synthetic inputs, and run tests in a bounded Stop hook.

Why it is useful

It turns a concrete hook bypass into a transferable practice: test alternative tool paths, check false positives, and bound automated retry loops.

Workflow

  1. Configure a PreToolUse guard for protected paths such as db/migrations/ across Edit, Write, and Bash.
  2. Check Bash commands for obvious writes or mutations aimed at protected paths, including redirection, tee, sed -i, rm, mv, cp, and truncate.
  3. Feed each hook synthetic tool-call JSON and assert both expected blocks and expected allows; include alternative mutation methods and false-positive cases.
  4. Configure a Stop hook to run the relevant tests and return failures to Claude for correction.
  5. Limit consecutive blocked stops; after three failures, hand control back to the user rather than looping indefinitely.

Tools / artifacts

  • Claude Code PreToolUse hook
  • Claude Code Stop hook
  • Synthetic hook-input JSON
  • Hook exit-code tests
  • Protected migration paths

Validation signals

  • The author reports that Edit was blocked but Bash redirection still changed the protected file.
  • A hook test reportedly caught an initial false positive on a command targeting ./dist.
  • The post describes a three-attempt limit on blocked stops.

Cautions

  • Treat command-pattern matching as defense in depth, not a security boundary: scripts, aliases, quoting, indirect writes, and other techniques can evade it.
  • Test dangerous command strings only as synthetic hook input; do not execute them.
  • A stop-attempt limit should return control and clearly report unresolved failures, not imply that tests passed.

Limitations

  • No implementation, JSON fixtures, or setup instructions are supplied.
  • The improved Bash guard and Stop hook are described but not independently verified.
  • The author acknowledges that scripts can still write protected files.

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

Selected Workflow [Workflow] Stage a Rust migration with recorded behavior, replay gates, and fallback

1 Upvotes

Stage a Rust migration with recorded behavior, replay gates, and fallback

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

What problem this solves

Incrementally migrate an application to Rust while checking that observed behavior remains consistent and preserving a fallback during the port.

Summary

Install a third-party Claude Code skill and MCP server, agree on migration and equivalence rules, record the original application's behavior, and port units behind a Rust front door. Gate each unit with Rust checks and replayed cases, use handoff files across sessions, and verify a pure-Rust cutover before deployment.

Why it is useful

The post supplies a concrete, adaptable migration sequence with artifacts, quality gates, and reported tests. Its tool-specific claims warrant verification, but the underlying workflow is more substantive than promotion alone.

Workflow

  1. Review the rust-anything repository and installation requirements, then install it and run rust-anything setup to configure the skill and MCP server.
  2. Ask Claude to plan the port, deciding equivalence rules, dependencies, scope, and approval checkpoints before implementation.
  3. Record representative original behavior and edge cases twice; explicitly decide which nondeterministic output can safely be normalized.
  4. Create a Rust front door with fallback to the original implementation, then track migration units in MAP.md.
  5. Port one unit at a time, using dependency-research subagents and parallel subagents for independent units where appropriate.
  6. Gate each unit with formatting, Clippy, tests, error-path checks, and replay of recorded cases; retain a switch back to the original.
  7. Write HANDOFF.md at checkpoints so later sessions can resume with the current state.
  8. Before cutover, replay against the pure-Rust version on a copy and review deployment steps that require human action.

Tools / artifacts

Validation signals

  • The author reports six development milestones checked on small applications in six languages.
  • The described workflow gates ports with formatting, Clippy, tests, error-path coverage, and full replay of recorded cases.
  • The author reports a 50,000-key search improving from 10 ms to 0.5 ms per query, and a separate Python slugify case improving 17x, with results checked before benchmarking.

Cautions

  • Inspect the third-party package, MCP server, and requested permissions before installation or use.
  • Recorded cases may contain sensitive data; control where recordings are stored and shared.
  • Passing replay only establishes agreement on recorded cases, not proof of equivalent behavior for all inputs. Normalization can also hide meaningful differences.
  • Keep production deployment, secrets, DNS changes, and removal of fallback under explicit human review; retain a rollback plan.

Limitations

  • The submission promotes the author's own tool, and its implementation and results are not independently verified in the provided material.
  • Performance claims are workload-specific and should not be generalized.
  • The post describes the process and setup entry point but does not provide detailed configuration, sample recordings, or commands for each migration stage.
  • Replay coverage can miss rare states, concurrency issues, and production-only behavior.

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

Selected Workflow [Workflow] Coordinate Unreal game agents with a shared contract and one editor driver

1 Upvotes

Coordinate Unreal game agents with a shared contract and one editor driver

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

What problem this solves

Coordinate parallel Claude Code agents on an Unreal game while keeping independently developed systems compatible and avoiding editor conflicts.

Summary

Assign agents separate source folders and give them a shared CLAUDE.md defining system interfaces and engineering rules. Serialize access to the Unreal editor, using Python scripts through MCP for editor operations. The author also uses contact sheets to reject inconsistent generated art before import.

Why it is useful

It provides a transferable coordination pattern with a concrete failure-driven rule: parallelize isolated code ownership, but serialize access to the shared editor. The playable project offers some evidence of usefulness, although implementation details and verification are limited.

Workflow

  1. Divide the codebase into distinct areas, such as spells, enemies, UI and game flow, and assign each area to an agent.
  2. Create a shared CLAUDE.md contract covering agreed names, core classes and cross-system rules, such as server authority and avoiding unnecessary per-frame Tick logic.
  3. Run agents in parallel on their assigned source folders, using the shared contract to keep their work compatible.
  4. Allow only one agent at a time to drive the Unreal editor; use Python scripts through MCP for tasks such as imports, actor placement, captures and PCG rebuilds.
  5. For generated art, repeat a shared style description and review contact sheets before importing selected assets.
  6. Check integrated systems and multiplayer behavior independently; the post does not describe a formal test process.

Tools / artifacts

  • Claude Code agents
  • Shared CLAUDE.md
  • Unreal Engine and C++
  • Unreal MCP server
  • Python editor scripts
  • ComfyUI and Krea-2
  • Blender scripts

Validation signals

  • The author reports producing a playable game with a complete gameplay loop in four days and links to a build.
  • The author reports 377 commits and says the shared contract helped independently written systems connect.
  • The author reports that concurrent editor drivers caused crashes and lost work, motivating single-driver access.
  • The author demonstrates a high-NPC-count scene, but supplies no performance measurements.

Cautions

  • Coordinate changes to shared files and use version control to reduce the risk of conflicting or lost work.
  • Verify licensing and usage rights for generated assets and third-party media.

Limitations

  • The post does not provide the actual CLAUDE.md, MCP configuration, agent prompts or Python scripts.
  • Results and commit counts are author-reported; no automated test, integration-review or performance-benchmark process is described.
  • Multiplayer is described as supposed to work, not as independently verified.
  • The reported scale and token consumption may be impractical for typical users.

Rate this workflow

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

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

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


This post was generated automatically from the workflow library database.


r/ClaudeWorkflows • • 1d ago

Selected Workflow [Workflow] Recover from auto-compaction thrashing by reducing input size

1 Upvotes

Recover from auto-compaction thrashing by reducing input size

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

What problem this solves

Repeated auto-compaction when a large file or tool output overwhelms Claude Code's context.

Summary

Avoid loading the full oversized input; use a targeted query or bounded subagent task, then reclaim conversation space with focused compaction or, as a last resort, a clear.

Why it is useful

Provides several concrete, adaptable recovery options with measured token reductions and a checked targeted-query result.

Workflow

  1. Identify the large file or tool output being repeatedly loaded into context.
  2. Replace the full read with a targeted operation, such as counting matching log lines with grep, and independently check the result where practical.
  3. Alternatively, delegate a bounded read or analysis to a subagent and request only the concise result.
  4. Use focused compaction, such as /compact keep only my question about counting ERROR lines, and check whether the Messages token count drops.
  5. If a fresh context is needed, preserve important requirements or findings first, then use /clear and resume with a smaller input.

Tools / artifacts

  • Claude Code v2.1.325
  • grep
  • /compact
  • /clear
  • Subagent
  • Messages token count

Validation signals

  • The author reports reproducing thrashing with a 30,000-line synthetic log and a forced 100k auto-compact window.
  • A targeted grep count reportedly returned 889 ERROR lines in 5 seconds, and the count was checked.
  • Focused compaction reportedly reduced the Messages count from 36.4k to 9.2k tokens.
  • A subagent reportedly read 1,500 lines and returned a number in 19 seconds.
  • /clear reportedly reduced the Messages count to 130 tokens.

Cautions

  • /clear discards the current conversation context; preserve important requirements and findings before using it.
  • Compaction or clearing alone may not prevent recurrence if the same oversized content is loaded again.

Limitations

  • Results come from one forced-window session, not a broad comparison under default settings.
  • The subagent result covers 1,500 lines; the post does not establish that it analyzed the entire 30,000-line log.
  • Reduced token counts after compaction and clearing do not by themselves demonstrate that the original full-file task was completed.
  • The related 'conversation could not be reduced' failure was not reproduced.

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

Selected Workflow [Workflow] Verify Minecraft plugins with a local server and in-game checks

1 Upvotes

Verify Minecraft plugins with a local server and in-game checks

Workflow value: 76/100
Status: active · Freshness: 70/100 · Confidence: 0.91 · Level: advanced
Categories: Quality Control, Token Saving, Context & Memory, Debugging, CLAUDE.md, Skills, MCP, Subagents
Original source: r/ClaudeAI post/comment

What problem this solves

Claude Code can invent version-incompatible Minecraft plugin APIs and report changes as working without testing them in a running game.

Summary

Use mcflow to scaffold a version-specific Claude Code environment, then research, build, exercise a plugin on a local Paper server, inspect the result in-game, and retain techniques that passed live tests.

Why it is useful

This is a concrete, installable workflow that connects Claude Code implementation to runtime and visual verification, with reusable version-tagged knowledge rather than relying on generated code alone.

Workflow

  1. Install mcflow with pipx and initialize a workspace for the target Minecraft version using mcflow init.
  2. Run mcflow doctor to check the required Java version and available JDKs.
  3. Use the generated project rules, skills, and agents to research the target-version APIs and implement the plugin.
  4. Build the plugin and use the MCP server to control a local Minecraft server, issue console commands, and inspect logs.
  5. Exercise the change with simulated players or load tests where appropriate, and use the game client integration to inspect visual behavior.
  6. Record techniques that pass live tests in the version-tagged knowledge base before reporting the change.

Tools / artifacts

  • mcflow v0.1.0: https://github.com/LadonON/mcflow
  • pipx install git+https://github.com/LadonON/mcflow.git@v0.1.0
  • mcflow init and mcflow doctor
  • Generated CLAUDE.md, AGENTS.md, skills, and helper agents
  • Minecraft server-control MCP and RCON
  • Paper server, Fabric client mod, and simulated players
  • spark profiler and TokToken code search
  • Version-tagged knowledge base

Validation signals

  • The author reports CI running a real server end-to-end on Windows, macOS, and Linux.
  • The proposed workflow includes runtime server tests, log inspection, and in-game visual checks beyond compilation.
  • No independent test results or example verification run are included in the post.

Cautions

  • Review the repository and its permissions before installing and running third-party code.
  • Keep server controls and RCON restricted to a trusted local environment, and protect account credentials.
  • Run load tests only against systems you control or are authorized to test.

Limitations

  • The post does not show a complete example run, MCP configuration, or exact commands for visual and bot testing.
  • CI coverage and verification capabilities are author claims, not independently demonstrated in the provided material.
  • The project is early-stage and the workflow is specialized to Minecraft.

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

Selected Workflow [Workflow] Coordinate Claude Code agents with project memory, worktrees, and verification gates

1 Upvotes

Coordinate Claude Code agents with project memory, worktrees, and verification gates

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

What problem this solves

Keeping a multi-session, multi-agent project coordinated while checking generated content, user feedback, simulation behavior, and deployments.

Summary

Use a small management folder as persistent project memory, coordinate parallel agents through a lead session and separate worktrees, and apply independent checks and human feedback before shipping.

Why it is useful

The post provides a repeatable coordination pattern with concrete artifacts, a feedback-to-fix loop, and lessons from both testing and a missed deployment failure.

Workflow

  1. Maintain STATUS.md for current state, OPEN.md for numbered questions and risks, an append-only decisions.md, and an inbox for tasks requiring the human.
  2. Instruct new sessions through CLAUDE.md to read the management files first.
  3. Have a lead session plan work, write briefs, review agent reports, and integrate changes; assign subagents separate git worktrees and do not let them commit.
  4. For factual creative content, record source events with two links and a note explaining the intended joke; use fictional composites in the published text and lint for real company names.
  5. Turn player feedback into work by tracing each complaint to the relevant screen, implementing fixes, and reviewing them with a human on a private preview.
  6. Check deterministic simulations by replaying recorded runs exactly and running bots through many games to assess balance.
  7. Require the session to check the final result of every CI run it triggers, rather than assuming a deployment succeeded.

Tools / artifacts

  • CLAUDE.md
  • STATUS.md
  • OPEN.md
  • decisions.md
  • Human-task inbox
  • Git worktrees
  • Agent briefs and reports
  • Source-event log
  • Content lint
  • Recorded simulation replays
  • Balance-testing bots
  • CI pipeline and private preview

Validation signals

  • The author reports that the management files supported twelve sessions and approximately 530 commits.
  • A player's feedback was traced to screens, followed by six fixes and a private human review before shipping.
  • The author reports that zero of six outside visitors made a move before a tutorial, versus ten of twelve afterward; the author was one of the twelve.
  • Recorded runs must replay exactly, and bots reportedly play 10,000 runs to check balance; specific balance results are not provided.
  • A missed CI failure prompted an explicit instruction to check triggered run results.

Cautions

  • Review agent changes and source claims before publishing; linting for names does not by itself establish factual accuracy or legal safety.
  • Keep human approval and deployment checks in place when parallelizing work.

Limitations

  • The actual CLAUDE.md, agent brief templates, CI configuration, and worktree integration procedure are not supplied.
  • The claimed results and game metrics are self-reported, with small visitor samples and no independent confirmation.
  • Parallel agents repeated creative habits, and the author reports that substantial comedy text shipped without human rating.
  • The scale of the setup may be costly or unnecessary for smaller projects.

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

Selected Workflow [Workflow] Queue cross-model reviews through a credential-isolated GitHub worker

1 Upvotes

Queue cross-model reviews through a credential-isolated GitHub worker

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

What problem this solves

Obtain reviews from separately signed-in model CLIs without putting their credentials in the requesting session.

Summary

Use a private GitHub repository as a review queue and a home-machine worker to run isolated reviewer CLIs. Validate requests, authenticate and correlate responses, and monitor worker health before sending jobs.

Why it is useful

The comment provides a detailed, adaptable design for cross-model review, including request validation, response identity checks, concurrency limits, and health checks. Its main limitation is that the implementation and results are not available for independent verification.

Workflow

  1. Create a private queue repository and a GitHub App identity for worker responses.
  2. Have the requesting session open a labeled issue with a versioned request envelope, source repository ID, selected reviewers, payload size, part count, and hash.
  3. Inline the files needed for review, then gzip, base64-encode, and split the brief into numbered comments.
  4. Run a worker that checks requester and runner allowlists, source exclusions, payload completeness and hash, size limits, and daily caps before accepting a request.
  5. Run pinned reviewer CLIs under the worker's own sign-ins, with tools and connectors disabled, limited concurrency, and schema-valid structured output required.
  6. Post results as the GitHub App, echoing request and payload identifiers; have the client verify the bot identity and hashes before accepting them.
  7. Poll for results, use heartbeat and self-test status to avoid sending work to an unhealthy worker, and remove payload comments after processing.

Tools / artifacts

  • Private GitHub queue repository
  • GitHub issues and comments
  • GitHub App
  • Long-running local worker
  • Claude and other reviewer CLIs
  • Versioned request envelope and structured-output schema

Validation signals

  • The author describes using a private implementation with Claude calling Gemini.
  • The proposed design includes hash checks, structured-output validation, heartbeat and self-test reporting, and response identity checks.
  • No code, test results, or independent success reports are provided.

Cautions

  • Restrict queue and GitHub App permissions; payloads can contain sensitive source code, and deleting comments is not a guarantee of complete data removal.
  • Treat submitted briefs and model output as untrusted. Hashes provide integrity and request correlation, not authorization by themselves.
  • Enforce decompressed-size limits while processing payloads, and verify that tools and connectors are actually disabled.
  • Check the applicable CLI, account, and provider terms before automating signed-in sessions.

Limitations

  • The implementation is private, with no commands, configuration, schemas, or source code to reproduce directly.
  • Claims about the existing setup and its security are not independently verified.
  • Cloud credential behavior for the suggested mirror is explicitly unverified.

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

Selected Workflow [Workflow] Test Parallel Agent Waves and Bisect Integration Failures

1 Upvotes

Test Parallel Agent Waves and Bisect Integration Failures

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

What problem this solves

Detect and localize failures caused by interactions between parallel agent branches without always running the full suite after every merge.

Summary

Have each worker run targeted tests, merge its branch into an integration branch in a fixed order, and run the full suite on the combined result. If it fails, use first-parent Git bisect to find the integration step that introduced the failure.

Why it is useful

It gives a repeatable compromise between fast worker feedback and full integration verification, with a concrete method for narrowing down cross-branch failures.

Workflow

  1. Start from a known-good integration baseline and have each worker run tests relevant to its changes.
  2. Merge worker branches into the integration branch one at a time in a fixed order, retaining a first-parent integration history.
  3. Run the full test suite on the completed integration branch.
  4. If it fails, start a first-parent bisect with the failing tip and known-good baseline: git bisect start --first-parent <bad> <good>.
  5. Run git bisect run <test command>, inspect the identified integration step and interacting changes, then run git bisect reset.
  6. Alternatively, run the full suite after each merge and investigate the first merge that turns it red.

Tools / artifacts

  • Git worktrees
  • Integration branch
  • git merge
  • git bisect --first-parent
  • git bisect run
  • Targeted and full test suites

Validation signals

  • The proposed full-suite integration check can catch interactions that isolated branch tests miss.
  • The commenter gives a concrete example: one branch changes a function while another adds a call to its old version.
  • The post describes testing and bisecting, but does not report an actual run or measured result.

Cautions

  • Use a clean, dedicated integration worktree: bisect changes the checked-out revision, and test commands may have side effects.
  • Treat the identified merge as the point where the failure appeared, not proof that one branch alone is at fault.

Limitations

  • Bisect needs a correctly marked good baseline and bad tip, a reliable test command, and an appropriate first-parent history; the comment omits these setup details.
  • Flaky tests or failures that appear, disappear, and reappear across the merge sequence can make bisect misleading.
  • The logarithmic test-run estimate is conditional on a suitable history and consistent test outcomes.
  • There is no reported implementation outcome or benchmark.

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

Selected Workflow [Workflow] Parallel Claude Code development with living specs and independent PR review

3 Upvotes

Parallel Claude Code development with living specs and independent PR review

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

What problem this solves

Coordinating parallel Claude Code development while retaining project knowledge, isolating changes, and reviewing and testing them before merging.

Summary

Maintain an imported living project specification, run parallel agents in separate Git worktrees, and route their changes through independent review and human-managed PR merges. Use check files and headless application tests to validate changes without interacting with the real desktop.

Why it is useful

Combines several repeatable practices into a coherent development loop, with a public repository and concrete reported artifacts, though the evidence is primarily the author's account.

Workflow

  1. Put architecture, design conventions, and safety rules in AGENTS.md and feature-specific specifications, and import the shared instructions from CLAUDE.md.
  2. Update the specifications alongside code when development or review reveals a reusable rule.
  3. Assign parallel agent work to separate Git worktrees using T3 Code.
  4. Submit changes as pull requests and have a reviewer who did not write the code check them before the human owner merges.
  5. Use project checks and headless application self-tests to exercise behavior without touching the user's actual screen.
  6. Keep vault secrets out of material available to the AI.

Tools / artifacts

  • CLAUDE.md
  • AGENTS.md
  • Feature specification
  • T3 Code
  • Git worktrees
  • Pull requests
  • Check files
  • Application self-test flags: --snapshot, --dock-check, --helpers-check
  • https://github.com/edgetr/petal

Validation signals

  • The author reports 41 reviewed and merged PRs and commits addressing review findings.
  • The project reportedly contains approximately 37 check files and several headless self-tests.
  • The author describes concrete implementation difficulties, including Mission Control integration and main-thread blocking.

Cautions

  • Separate Git worktrees isolate changes but are not security sandboxes or substitutes for permission controls.
  • Keep credentials and vault contents outside agent-readable context; review changes before merging.
  • The advertised application is not notarized. Evaluate source and distribution trust before overriding macOS security warnings.

Limitations

  • The post promotes the author's product, although it includes substantive workflow detail and a source repository.
  • Reported commit counts, PR counts, and test coverage are self-reported and not independently verified here.
  • The post does not provide exact worktree setup commands, review prompts, or test results.
  • Large code and commit counts do not establish correctness or maintainability.

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

Selected Workflow [Workflow] Remove AI-style UI copy with a guarded Claude Code skill

1 Upvotes

Remove AI-style UI copy with a guarded Claude Code skill

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

What problem this solves

Remove repetitive, decorative AI-style UI copy without inventing claims or deleting functional interface elements.

Summary

Run an explicitly invoked Claude Code skill against a UI file to remove specified copy patterns, preserve functional content, and report changes. Optional surface rules cover visual styling. Regex counts and evaluation fixtures help check results.

Why it is useful

It offers a concrete, reusable skill invocation and a defensible review process, with explicit safeguards against invented copy and removal of functional UI elements.

Workflow

  1. Install or adapt the unslop-ui skill from the linked repository.
  2. Run /unslop-ui src/pages/landing.tsx on a target UI file; add --surface if visual styling should also be reviewed.
  3. Remove or rewrite the targeted patterns using only information supported by the source; leave existing unverified claims in place and flag them for a human task list.
  4. Preserve functional elements such as prop-driven state badges and visible form labels, and fix internationalized strings at their source.
  5. Review the report of what was removed or kept and why, including model-reviewed patterns counted separately from regex-detectable patterns.
  6. Use the counter and evaluation fixtures to check the result, then manually review changes and any flagged claims.

Tools / artifacts

  • unslop-ui Claude Code skill: https://github.com/felipebasurto/unslop-ui
  • /unslop-ui invocation and optional --surface flag
  • Python regex counter
  • Before-and-after examples and five evaluation fixtures
  • UI source files and internationalization strings

Validation signals

  • The author reports that regex-detectable patterns fell from 31 to 0 on the examples after one run in a fresh session.
  • The author describes five fixtures covering a clean screen, real state, form labels, internationalization, and invented facts.
  • The post explicitly notes that regex cannot assess every targeted pattern, so some require model review.

Cautions

  • Review edits for accessibility, functional state, localization, and unintended design changes before shipping.
  • A zero regex count does not establish that all problematic copy was found or that removals were correct.
  • Existing unsupported claims are flagged rather than verified or automatically removed.

Limitations

  • The reported improvement and fixture coverage are author claims, not independently verified results.
  • The post does not report fixture pass results or provide installation instructions.
  • The desired visual style is subjective, and optional surface rules could remove intentional design choices.

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

Selected Workflow [Workflow] Maintain dated, topic-based memory for always-on Claude agents

2 Upvotes

Maintain dated, topic-based memory for always-on Claude agents

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

What problem this solves

Always-on agents accumulate oversized or contradictory memory, may preserve unfinished guesses, and can lose the original task after a restart.

Summary

Use a small always-loaded memory with on-demand topic files, dated and attributed facts, a separate post-session memory update, and original-request recovery after restarts. Bind approvals to the exact outgoing payload and let them expire.

Why it is useful

The comment gives a repeatable memory and recovery pattern grounded in specific operational failures, with an additional concrete approval safeguard.

Workflow

  1. Keep a short set of memory lines always loaded; put other facts in topic files with a one-line instruction describing when each file should be read.
  2. Date each memory line and distinguish human-written facts from agent inferences. Prefer newer facts for conflicts and give human-written facts precedence over inferences.
  3. Do not update memory during a task. After the session goes quiet, run a separate pass over it and retain decisions rather than unfinished guesses.
  4. After a restart, have the agent reread the original request before resuming work.
  5. For actions requiring approval, bind approval to the exact text or payload and do not proceed if approval is not received by the deadline.

Tools / artifacts

  • Claude Code agents
  • Always-loaded memory list
  • On-demand topic memory files
  • Original request
  • Post-session memory review pass
  • Payload-specific approval mechanism

Validation signals

  • The author reports operating several always-on agents for support, code, and marketing.
  • The author reports that a single growing notes file led to unread content, contradictory facts, and use of an obsolete rule.
  • The author describes a scheduled run that failed to complete after losing context and asking for the brief again.
  • The author reports that the revised memory approach works, but provides no quantitative results or independent test.

Cautions

  • Treat agent-inferred memory as less authoritative than human instructions and review sensitive or consequential memory updates.
  • Ensure an approval is valid only for the approved payload, and fail closed when it expires.
  • Protect memory files and original requests from unauthorized modification.

Limitations

  • No configuration, code, or concrete implementation of the quiet-session trigger, restart recovery, or approval gate is provided.
  • The relative priority of an older human-written fact and a newer agent-inferred fact is not fully specified.
  • Reported improvements are anecdotal and lack measured before-and-after results.

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

Selected Workflow [Workflow] A gated Claude Code workflow for production features and bugs

2 Upvotes

A gated Claude Code workflow for production features and bugs

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

What problem this solves

Maintaining quality and human oversight when Claude Code works on production features, bugs, and parallel tasks.

Summary

Use reviewed plans and test-first implementation, enforce automated checks and an independent diff review, then rely on CI and human review before merging. Periodically turn recurring corrections into improved rules and skills.

Why it is useful

It describes a repeatable end-to-end workflow with specific stopping conditions, automated checks, independent review, and human oversight, even though its implementation details and measured results are limited.

Workflow

  1. Use a planning skill for each feature or bug, and have a separate agent review the plan for gaps and testable acceptance criteria; require a failing test in bug plans.
  2. Have backend or frontend testing subagents write tests first, then implement in small steps. Stop and ask a human if the same problem fails twice.
  3. Run hooks for static analysis, linting, and type checks on changed files, alongside project-specific architecture, coverage, and mutation-testing gates.
  4. Have an independent Claude process review the diff without the implementation session's context; block commits and pushes until it passes.
  5. Open a draft merge request, monitor the full CI pipeline, and address failures before a human colleague reviews and merges.
  6. For parallel work, use separate Git worktrees with separate test databases; use stacked merge requests for epics.
  7. Log corrections and review them monthly to update rules and skills.

Tools / artifacts

  • Claude Code plan mode
  • Planning skill and reviewer agent
  • Backend and frontend testing subagents
  • Hooks
  • PHPStan level 10
  • Deptrac architecture rules
  • Coverage and mutation tests
  • Independent diff review
  • Git worktrees and isolated test databases
  • Draft merge requests and CI
  • Correction retro log

Validation signals

  • The author reports using the setup daily for several months and says it works well.
  • The described process includes automated quality gates, independent diff review, full CI, and human merge review.
  • No before-and-after measurements, configuration examples, or independent success reports are provided.

Cautions

  • Keep human review and merge approval; an independent model review is not a substitute.
  • Investigate flaky CI failures rather than repeatedly retrying them to obtain a green result.
  • Use isolated test databases and avoid giving autonomous agents broader production permissions than needed.

Limitations

  • The post is primarily a request for advice and does not include hook configurations, prompts, or implementation details for its gates.
  • The effectiveness claim is subjective and unquantified.
  • The author reports rule growth and slow feedback loops; the strict gates may be expensive to maintain.
  • No evidence is provided that the setup achieves fully unattended, production-ready delivery.

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

Selected Workflow [Workflow] Compose and Validate a DAW Mix Through MCP

2 Upvotes

Compose and Validate a DAW Mix Through MCP

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

What problem this solves

Let Claude compose and mix music in a DAW despite being unable to hear, while reducing the tokens needed to express note patterns.

Summary

Use Lathe's MCP server to create and edit a song, express repeated musical parts in compact step notation, and use mix measurements and before/after comparisons to guide and verify changes.

Why it is useful

It combines compact musical representations with a concrete measurement-and-correction loop, including an example of a meter catching a problematic final change.

Workflow

  1. Use a DAW with an MCP server that exposes song-editing, playback, and export tools; the post uses Lathe.
  2. Give Claude a song objective and have it create tracks, instruments, and parts using compact pattern notation rather than individual note JSON objects.
  3. Run analyze_mix to inspect loudness, distortion risk, and frequency conflicts by track and section.
  4. Make a mix change and use compare_mix to compare rendered measurements before and after it.
  5. Check the final output against the meter and undo changes that push it past the safe limit.
  6. Inspect part repetition and swing readback to catch arrangement or rhythm interpretation errors before export.

Tools / artifacts

Validation signals

  • The author reports producing a 40-bar track of approximately 2,090 notes using roughly 25 compact patterns and about one-tenth the tokens of note JSON.
  • The meter reportedly caught a final treble boost that pushed the mix past its safe limit, and Claude removed the boost.
  • The author reports adding repetition counts and swing-aware readback after observing arrangement and rhythm interpretation problems.

Cautions

  • Check final output levels after all processing; objective measurements do not replace human listening for musical quality or audible defects.
  • The author says neither person listened until the track was complete, so subjective quality is not established by the reported measurements.

Limitations

  • The post does not provide MCP installation or configuration steps, tool schemas, or a complete notation grammar.
  • The token savings and mix results are author-reported and not independently verified.
  • The post promotes the author's project, though it includes enough implementation detail to describe a reusable 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 • • 3d ago

Selected Workflow [Workflow] Enforce agent coding rules with edit hooks and a legacy-code ratchet

2 Upvotes

Enforce agent coding rules with edit hooks and a legacy-code ratchet

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

What problem this solves

Agent-written code can pass functional checks while creating oversized, noisy diffs that slow review. Existing violations also make strict rules difficult to introduce.

Summary

Give coding agents concise rules, baseline existing size violations, and enforce non-regression through an edit-time Claude Code hook, a pre-commit hook, and CI.

Why it is useful

It provides a reusable enforcement pattern with multiple checkpoints and a practical way to adopt rules without first fixing every legacy violation. The described tests offer some evidence, although results are not independently confirmed.

Workflow

  1. Review the published rules and adapt the size limits and language-specific linter configuration to the project.
  2. Install the agent instructions and audit tooling, previewing the installer and reviewing changes to existing instruction files first.
  3. Seed a baseline of existing audit violations so legacy issues are tracked as ceilings rather than blocking initial adoption.
  4. Configure the Claude Code edit hook to report newly breached limits immediately.
  5. Add the audit to pre-commit and CI so violations are also checked at commit and integration time.
  6. Test the setup with an edit that exceeds a limit; confirm that the hook reports the problem and the later checkpoints enforce the policy.
  7. Use explicit staging and review diffs, including changes to code outside the requested scope.

Tools / artifacts

  • Pelloux Guidelines repository: https://github.com/RemiPelloux/pelloux-guidelines
  • CLAUDE.md and other agent instruction files
  • Python standard-library audit and seeded violation baseline
  • Claude Code hook
  • Pre-commit hook
  • GitHub Action
  • Language-specific linter configurations

Validation signals

  • The author says the underlying rules were developed across about 30 repositories.
  • The author reports that the audit runs against its own code in CI.
  • The author describes a hook test in which an oversized function produces exit code 2 and a message for the agent.
  • The author reports that one frontend has approximately 3,600 flagged functions, illustrating the need for a baseline.

Cautions

  • The suggested installation pipes a remote script into bash. Inspect the script and repository before running it; use the advertised dry-run option to preview changes.
  • Review changes to existing agent instructions and hooks rather than assuming the installer preserves local configuration.
  • Keep normal code review and tests: size checks do not establish correctness or safety.

Limitations

  • The post promotes the author's own project, and all effectiveness claims are author-reported.
  • The function detector is heuristic rather than a parser, so exact counts can disagree with language-aware tooling.
  • Strict size limits may encourage unnecessary splitting or generate substantial baseline noise.
  • The post does not provide complete hook, baseline, or CI configuration commands; readers must consult the repository.
  • No before-and-after review-time measurements or independent validation 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.


r/ClaudeWorkflows • • 3d ago

Selected Workflow [Workflow] Check Claude-generated CAD for floating features before printing

1 Upvotes

Check Claude-generated CAD for floating features before printing

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

What problem this solves

Claude-generated CAD parts can pass fit checks while containing floating features that are unreliable to print.

Summary

Use a Claude Code skill with CadQuery to measure parts, constrain build resources, inspect STL output and rendered geometry, and check for floating features before recommending printable changes.

Why it is useful

Provides a reusable quality-control skill and a concrete comparison showing why detecting a floating feature is not enough unless the workflow also recommends a printable correction.

Workflow

  1. Use the linked cad-parts skill with a Claude Code and CadQuery CAD project.
  2. Measure the relevant geometry rather than guessing dimensions, and preserve parts that already fit.
  3. Run CAD builds under a memory cap, then check the generated STL and inspect a rendering.
  4. Look for floating islands or features that depend on supports, and recommend a printable fix when found.

Tools / artifacts

Validation signals

  • Author reports six runs with and six without the skill on a robot-shell task containing a floating wall.
  • Both configurations reportedly detected the wall in all six runs, but only the skill-equipped runs recommended a printable fix in all six.
  • Author reports a print record of 79 prints, with no failures attributed to bad STLs or broken working parts; this does not establish that the skill prevented those failures.

Cautions

  • A passing STL or floating-island check does not establish printability, structural integrity, or safe operation; review designs and test critical parts independently.
  • Use a suitable memory cap for CAD builds; the post does not specify its configuration.

Limitations

  • The comparison is author-reported, small, and focused on one planted defect.
  • The post does not describe installation, exact commands, memory-cap configuration, or check implementation; those details require consulting the repository.
  • The checks cover only some failure types; insertion paths, loads, and tolerances need further checks.
  • No physical-print validation of the recommended fix is reported.

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

Selected Workflow [Workflow] Turn meeting notes into a checked project knowledge base

2 Upvotes

Turn meeting notes into a checked project knowledge base

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

What problem this solves

Meeting decisions, commitments, questions and ownership are easily lost across a busy project.

Summary

Maintain a local, assistant-oriented project knowledge base. Have Claude route meeting notes into dated tasks and person-specific questions, preserve conflicting accounts with sources, and use scripts plus a fresh-context agent to check important changes.

Why it is useful

It combines a repeatable capture-and-retrieval loop with provenance, mechanical checks and independent review, while documenting maintenance and privacy limits.

Workflow

  1. Create a local text-file knowledge base with an AGENTS.md entry point, writing rules, a routing map, and files for tasks, completed work, people, questions and contradictions.
  2. Add headers explaining each file's contents and writing rules. Instruct the assistant to consult files rather than rely on memory and to retain conflicting accounts with their sources and dates.
  3. After each meeting, provide notes and decisions. Have the assistant update dated tasks and questions by person, asking for clarification when uncertain.
  4. Start chats with a short summary of overdue or urgent tasks; before one-on-ones, request outstanding promises and questions for that person.
  5. Store draft-and-edited message pairs to help the assistant adapt to the user's writing style.
  6. Run mechanical Python checks on important changes and use a second agent with clean context to review major updates.
  7. Separate lightweight reading from heavier write workflows, and periodically compact oversized files and simplify checks.
  8. Keep passwords out of the base and replace names with roles before sending material to external search or services.

Tools / artifacts

  • AGENTS.md
  • Local text-file knowledge base
  • Claude project containing rules
  • Python validation scripts
  • Second agent with clean context

Validation signals

  • The author reports using the system for 3.5 months and estimates saving about eight hours per week.
  • Scripts reportedly catch malformed task lines, unwanted words and real names in outside-facing text.
  • After cleanup, some oversized files reportedly became four times smaller.

Cautions

  • Use only with organizational approval and an appropriate data-processing agreement; local storage does not prevent the model provider from receiving file contents or retaining chats.
  • Name-detection scripts and role-based substitutions are safeguards, not guarantees against disclosure.
  • The described 'forget it' command does not establish secure deletion from files, logs or provider-held chats.

Limitations

  • No runnable scripts, complete file schemas or exact startup commands are provided.
  • Time savings and checker effectiveness are self-reported, with no independent measurements.
  • The author reports substantial maintenance, context growth and usage-limit pressure.
  • The post does not explain how conflicting updates or erroneous extracted tasks are corrected in practice.

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

Selected Workflow [Workflow] Turn Unstated Requirements into Runnable Checks

2 Upvotes

Turn Unstated Requirements into Runnable Checks

Workflow value: 76/100
Status: active · Freshness: 70/100 · Confidence: 0.96 · Level: intermediate
Categories: Quality Control, Token Saving, Debugging, Shipping
Original source: r/ClaudeAI post/comment

What problem this solves

Coding agents can implement the literal request while omitting operational and security requirements the user did not think to specify.

Summary

Give the coding agent a reusable instruction to identify implicit stakeholder needs, turn them into runnable checks, implement reasonable safeguards, and report the results and omissions.

Why it is useful

It provides a copyable instruction and a repeatable planning-to-verification loop, backed by reported before-and-after results and linked artifacts.

Workflow

  1. Add the post's instruction paragraph to the agent's prompt before starting a build.
  2. Ask the agent to identify needs and potential misuse involving users, heavy or careless users, attackers, and maintainers.
  3. Turn those needs into checks and implement changes needed to pass them, unless they contradict explicit requirements.
  4. Use sensible defaults for unspecified decisions, explain how to change them, and leave additions that expand access switched off by default.
  5. Run the checks and report what was added, what passed, and what was omitted and why.

Tools / artifacts

Validation signals

  • The author reports that the prompt led to login-guessing protection in 11 of 11 builds, versus 0 of 10 without it.
  • The author reports an approximately 6% cost increase and says one prompted project was new to the paragraph.
  • The post links builds, tests, and model responses, but their contents have not been independently verified here.
  • The reported tests were written by one of the models being compared.

Cautions

  • Review proposed implicit requirements before allowing consequential scope, permission, data, or infrastructure changes; the prompt's instruction to decide autonomously should not override approval boundaries.
  • Independently review security controls and tests. Login throttling should account for denial-of-service and account-lockout risks.

Limitations

  • Results are author-reported and do not establish that the prompt reliably finds all missing requirements.
  • The strongest before-and-after evidence concerns one type of security omission.
  • The comparison's test authorship and limited project range constrain generalization.

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

Selected Workflow [Workflow] Use searchable ADRs to constrain agent implementations

1 Upvotes

Use searchable ADRs to constrain agent implementations

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

What problem this solves

Coding agents may overlook or misinterpret architectural rules when implementing AI-generated PR summaries, producing inaccurate counts or unvalidated lists.

Summary

Retrieve relevant versioned architecture decisions through MCP and copy their operative rules into the implementation plan. When an agent finds a loophole, revise the ADR with explicit prohibited and permitted behavior, then repeat the task from a clean state. For exact lists and counts, make code authoritative and use model output only for validated annotations.

Why it is useful

It combines a repeatable context-retrieval and rule-revision loop with a concrete design boundary: code owns exact data, while model-generated annotations are validated against it. The reported before-and-after result is useful but narrowly scoped.

Workflow

  1. Store relevant engineering decisions in versioned ADRs and make them searchable through MCP.
  2. Give the agent a task that identifies applicable internal rules; have it retrieve the ADRs and copy the actual rules into its plan before coding.
  3. Implement exact lists and counts in code, while allowing the model to supply prose or short per-item notes.
  4. Drop model-generated notes that refer to items absent from the authoritative list.
  5. Inspect the implementation for rule violations. If an ADR permits an unintended workaround, revise it to state the prohibited approach, scope, and allowed behavior explicitly.
  6. Reload the ADR, confirm the revised wording is returned by search, and rerun the same brief from a clean state to assess the change.
  7. Separately check response-length settings and define a safe fallback for truncated or malformed structured output; the list/count ADR did not resolve these issues.

Tools / artifacts

  • Versioned architecture decision records
  • MCP-searchable ADR corpus
  • Agent implementation plan
  • PR review system
  • Authoritative file list and deterministic renderer

Validation signals

  • The author reports that Claude initially built the file table and count from the real file list.
  • After the ADR revision, a clean Grok rerun reportedly used code-owned lists and counts and dropped notes referring to nonexistent files.
  • The author verified that search returned the revised ADR before rerunning.
  • The post identifies unresolved response-length and malformed-output failures rather than presenting the ADR change as a complete fix.

Cautions

  • Validate model-generated references against authoritative data before rendering.
  • Handle truncated or malformed model output with a safe fallback rather than publishing raw structured output.
  • Review and test the implementation; an ADR does not guarantee compliance.

Limitations

  • One task on the author's codebase, run once per configuration, is not a benchmark.
  • The revised ADR was tested on Grok, not demonstrated in a Claude before-and-after run.
  • No automated test results, exact MCP setup, or full implementation are included.
  • The ADR change did not address the response-length or truncation failures.

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.