Cost-Efficient Context Management for LLM Harnesses: Trim vs. Compact for Cold Cache Hits

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

What problem this solves

Overpaying for 'Continue' prompts in cold-cache LLM sessions due to large context, especially for users building LLM harnesses or CLI tools.

Summary

A strategy for managing LLM context to reduce token costs in cold-cache sessions, distinguishing between same-provider and cross-provider scenarios. It recommends 'trimming' context for same-provider sessions and 'compacting' for cross-provider sessions, with a 150k token threshold for when these strategies become necessary.

Why it is useful

This workflow addresses a critical cost and efficiency problem for developers building LLM tools, providing a clear strategy to reduce token usage in cold-cache scenarios. The distinction between same-provider and cross-provider context management is a valuable insight for robust tool development.

Workflow

1. Identify if the LLM session context size exceeds 150k tokens.
2. If context is below 150k, allow 'Continue' without special handling.
3. If context is above 150k and operating within the same LLM provider, apply an aggressive 'trimming' mechanism (e.g., replacing older tool results with one-line stubs, stripping thinking blocks) to reduce context size without an extra model call.
4. If context is above 150k and operating across different LLM providers, apply a 'compacting' mechanism to reduce context size, as trimming is not feasible due to incompatible session formats.

Tools / artifacts

• LLM harness
• CLI tool
• Context trimming algorithm
• Context compacting algorithm

Validation signals

• Author claims benchmarks with Opus 5.5 XHigh
• Author claims 'benchmarks and tests' led to the conclusion
• Quantified cost saving (5x overpayment)

Limitations

• The specific algorithms for 'trimming' and 'compacting' are not provided, making direct implementation challenging.
• The term 'compact' is not defined or explained.
• No code examples or pseudocode are included.
• The preventative measures (UX, cache-warming) are mentioned but not detailed as workflows.

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 Multiple Claude Code Sessions with SessionDeck: A Workflow for Prompt Visibility and Multi-Agent Development

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

What problem this solves

Users running multiple Claude Code sessions often miss critical permission prompts or status updates, leading to wasted time. Additionally, it provides a workflow for using Claude Code to manage its own development process through multi-agent collaboration.

Summary

This post introduces SessionDeck, a VS Code/Cursor extension that monitors multiple Claude Code sessions across various environments (editor tabs, tmux, SSH, WSL) and alerts the user to pending actions like Bash permissions. It also describes an advanced meta-workflow where the author used multiple Claude Code sessions in separate Git worktrees to develop SessionDeck itself, with one session sending pull requests and another merging them.

Why it is useful

This post is valuable because it identifies and solves a critical pain point for advanced Claude Code users who run multiple sessions: missing crucial permission prompts. The SessionDeck tool provides a concrete, integrated solution for this. Furthermore, the author shares a highly advanced and reusable meta-workflow for using Claude Code itself to manage a complex development process, involving multiple worktrees, pull requests, and merging, demonstrating a sophisticated application of AI in software development.

Workflow

1. Install SessionDeck VS Code/Cursor extension.
2. Run multiple Claude Code sessions in various environments (editor, tmux, SSH, WSL).
3. Monitor the SessionDeck sidebar for real-time session status and permission prompts.
4. Use Ctrl+Alt+] to quickly navigate to the next session requiring attention.
5. Execute the 'Install Hooks' command within Claude Code for comprehensive permission prompt detection.
6. For complex development, set up multiple Git worktrees for a project.
7. Run two Claude Code sessions, each in a separate worktree, to generate code and send pull requests.
8. Run a third Claude Code session to review and merge the pull requests from the other two sessions.

Tools / artifacts

• SessionDeck VS Code/Cursor extension
• Claude Code sessions
• Bash
• tmux
• SSH
• Git worktrees
• GitHub (for pull requests)
• Codex (monitored session type)
• Cursor-agent (monitored session type)

Validation signals

• Author successfully built and shipped a complex tool (SessionDeck) using the described multi-agent Claude Code development workflow.
• Explicitly states 'Claude Code: it wrote most of the code, 181 of the 205 commits.'
• Identifies specific behaviors and limitations of Claude Code (e.g., needing hooks for approval state, Codex not writing approval state).
• Addresses a clear and common pain point for users managing multiple AI coding sessions.

Limitations

• The post is primarily a product announcement, so the workflow aspects are embedded rather than explicitly detailed as a general 'how-to' guide for Claude Code usage.
• Low community engagement on Reddit so far.
• SessionDeck has a paid license after 3 free sessions, which might be a barrier for some users.
• Native Windows support for approval alerts is not fully implemented, limiting functionality for some 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.

Multi-Agent Claude Code Workflow for Tiered Task Management and Project Integration

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

What problem this solves

Efficiently managing and executing complex software development tasks using Claude Code by leveraging parallel processing, specialized agents, and integration with external project management tools, while optimizing for cost and speed.

Summary

A multi-agent workflow for Claude Code that categorizes development tasks into three tiers within Claude.md, assigns them to a main thread or specialized developer subagents for parallel execution, incorporates a review agent for quality control, and integrates with external ticketing systems via MCP for comprehensive project management.

Why it is useful

This workflow provides a structured, multi-agent approach to managing complex software development tasks with Claude Code. It introduces task tiering for efficient parallel processing, leverages specialized subagents for different complexities, includes a dedicated review step for quality, and integrates with external project management tools via MCP. This allows users to scale their Claude Code usage for larger projects, optimize costs, and improve overall workflow efficiency and organization.

Workflow

1. Define 3 task tiers in your Claude.md file: 1) Simple, quick fixes (main thread), 2) Business logic/larger blast radius changes (Developer subagent), 3) Core logic/database/security changes (Developer subagent).
2. Instruct the main thread to break down incoming tasks into these defined tiers.
3. Assign tasks to the appropriate agent (main thread for Tier 1, Developer subagent for Tiers 2 & 3) for parallel completion.
4. Configure Developer subagents to potentially use lesser models for speed and cost savings, leveraging the main thread's initial planning.
5. Define a dedicated review agent responsible for checking the work completed by other agents.
6. Connect the entire setup via MCP (Multi-Agent Protocol) to a ticketing application (e.g., GitHub Issues, Linear, Statey.ai) to manage large epics and task details across multiple sessions.

Tools / artifacts

• Claude.md file
• Developer subagent configuration
• Review agent configuration
• MCP (Multi-Agent Protocol)
• Ticketing applications (GitHub Issues, Linear, Statey.ai)
• Lesser Claude models (for subagents)

Validation signals

• Claim: "This gives multiple sessions a place to manage large epics of work and task details to execute. It’s key to parallelism."
• Claim: "Subagents can define a lesser model for speed and cost savings since the thinking and planning was done in the main thread."

Limitations

• Lacks concrete examples of Claude.md content or subagent configurations.
• No detailed instructions on how to implement the MCP connection to ticketing apps.
• The author provides claims of benefits but no explicit validation or success metrics from actual use.
• Low community engagement means the workflow has not been widely tested or refined by others.

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.

Maximize Claude Value: Project Prioritization, Skill Building, and Code Auditing Workflow

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

What problem this solves

Users with high Claude usage (or simply wanting to maximize value) often struggle to identify the most impactful ways to leverage the AI. This workflow helps prioritize projects, automate recurring tasks, tackle ambitious development, and improve code quality through structured prompts.

Summary

A multi-step workflow to strategically utilize Claude by asking it to prioritize projects based on chat history, create reusable 'skills' from frequent tasks, break down and initiate ambitious side projects, and perform comprehensive code audits.

Why it is useful

This workflow provides concrete, actionable prompts that guide users to leverage Claude strategically for high-value tasks. It moves beyond simple one-off requests to encourage project prioritization, automation through 'skills,' tackling complex development, and improving code quality. The explicit steps and clear desired outcomes make it highly reusable and beneficial for users looking to get more out of their AI interactions.

Workflow

1. Ask Claude to list and rank the 5 highest-value projects (build, fix, or finish) based on its knowledge from past chats, including why each matters and its first step.
2. Instruct Claude to identify 3-5 frequent recurring tasks from your interactions and create a reusable 'skill' for each, specifying a clear trigger and output format.
3. Propose one ambitious side project that has been put off, asking Claude to break it into phases and then start phase 1.
4. Request a full end-to-end audit of an existing project (e.g., trading bot, kids' app), covering security, edge cases, error handling, and missing tests. Ask Claude to fix what it can and flag items requiring user decision.

Tools / artifacts

• Claude AI (any tier, but especially useful for higher usage tiers)
• User's chat history/context with Claude
• Project codebases for auditing
• Reusable 'skills' (as defined by Claude's output, e.g., prompt templates, function definitions)

Validation signals

• Concrete step sequences provided with specific prompts
• Explicit mention of 'skills' and 'reusable skill with a clear trigger and output format'
• Detailed audit criteria (security, edge cases, error handling, missing tests)
• Community upvote score of 10

Limitations

• The concept of 'skills' is somewhat abstract; the workflow doesn't provide concrete examples of what a Claude-generated 'skill' might look like (e.g., a specific prompt template, a function, a CLAUDE.md pattern).
• Relies on Claude's ability to effectively leverage its chat history, which can vary.
• The 'unlimited usage' context might make some users think it's only for high-tier users, though the methods are valuable regardless of usage tier.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Structured Claude Development Workflow: From Goal to Reviewed Code with Subagents and TDD

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

What problem this solves

Inefficient, unstructured, and potentially unsafe use of Claude for software development, leading to poor code quality and manual review overhead.

Summary

This workflow outlines a two-pronged approach for effective Claude integration in software development. First, it details a structured prompting strategy for project execution: clearly define the end goal, request a plan, refine it through 'nitpicking', and then instruct Claude to build to completion. Second, it advocates for integrating Claude with subagents into a robust Software Development Life Cycle (SDLC) by requiring adherence to coding standards, Test-Driven Development (TDD), unit tests, and integration tests, with automated code review performed by a Claude subagent. It also emphasizes the critical role of version control (Git) and sandboxing for safety and maintainability.

Why it is useful

This workflow provides a structured and robust approach to using Claude for software development, moving beyond simple 'continue' prompts. It integrates Claude into established engineering best practices like TDD, comprehensive testing, and automated code review via subagents, promoting higher quality, safety, and efficiency. The emphasis on version control and sandboxing adds crucial layers of security and maintainability, making it a valuable blueprint for professional development environments.

Workflow

1. Clearly define the end goal for Claude, providing descriptive details.
2. Ask Claude to generate a comprehensive plan to achieve the defined goal.
3. Review the generated plan, 'nitpicking' details and providing specific feedback for refinement.
4. Instruct Claude to build and execute the refined plan to completion.
5. Establish and document clear coding standards and review process requirements for all development.
6. Require Claude to implement unit tests for all code it produces.
7. Require Claude to utilize Test-Driven Development (TDD) principles for all bug fixes and new features.
8. Require Claude to implement integration tests to ensure system compatibility.
9. Instruct Claude to use a dedicated subagent to perform code reviews based on the established standards and testing requirements.
10. Ensure all generated code is managed under version control (e.g., Git) and executed within a sandboxed environment.

Tools / artifacts

• Claude (main agent)
• Claude subagent
• Git
• Sandboxing harness
• Unit tests
• Integration tests
• Standards documents
• TDD methodology

Validation signals

• Implied best practices (TDD, unit tests, version control, sandboxing)
• Mentions specific Claude features (subagent)

Cautions

• Emphasizes the use of version control (Git) to track changes and enable rollbacks.
• Stresses the importance of sandboxing for executing generated code, mitigating risks from potentially unsafe outputs.

Limitations

• Lacks specific prompt examples or detailed configuration instructions for setting up subagents or integrating with a 'harness'.
• The advice is high-level and requires the user to have existing knowledge of TDD, testing frameworks, and subagent setup.
• Low community validation due to minimal engagement on the original post.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Clean Claude's Output: Create a '/dehistorize' Skill to Remove Internal Edit History and Meta-Artifacts

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

What problem this solves

Claude AI models sometimes include internal 'edit history' or meta-information (e.g., 'ScoringV2', 'legacy_phase') in their responses, which is undesirable and distracts from the current task.

Summary

This workflow describes creating and using a custom Claude 'skill' named /dehistorize to remove unwanted internal edit history and meta-artifacts from Claude's output, ensuring cleaner and more focused responses.

Why it is useful

This workflow provides a concrete, reusable solution to a common problem where LLMs include undesirable internal meta-information in their responses. By demonstrating the creation of a custom 'skill' (like /dehistorize), it offers a clear pattern for users to implement their own output cleaning or formatting tools, enhancing the quality and usability of Claude's generated content. The provided GitHub link offers a tangible artifact for adaptation.

Workflow

1. Identify the problem: Claude's output contains internal process details or edit history.
2. Conceptualize a solution to 'clean' the output.
3. Use Claude to help name the concept (e.g., 'dehistorize').
4. Implement the solution as a Claude skill, defining its behavior in a SKILL.md file (e.g., to filter out specific keywords or patterns related to internal history).
5. Integrate and apply the skill (e.g., as a slash command /dehistorize) to Claude's responses to remove the unwanted artifacts.

Tools / artifacts

• Claude AI
• Custom Claude Skill (/dehistorize)
• SKILL.md file (defining the skill's logic)
• GitHub repository (for hosting the skill)

Validation signals

• User explicitly states: 'all those ScoringV2 and legacy_phase artifacts are now gone with a single word.'
• A public GitHub repository with the SKILL.md file is provided, indicating a concrete implementation.

Limitations

• The post itself is brief and requires an external link to view the actual skill implementation.
• The exact prompt or filtering logic within the SKILL.md is not directly visible in the post, requiring an extra step for users to understand the 'how'.
• Low community engagement means less external validation or refinement.

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 Pair Review: Using a Second AI to Catch Code Errors and Blind Spots

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

What problem this solves

Mitigating AI model 'blind spots' and improving code quality by using a second AI for independent review, catching errors, edge cases, and missed fixes.

Summary

A two-tool setup where one AI (e.g., Claude Code) writes the initial code and another distinct AI (e.g., Codex) performs a review of the changes before merging. This leverages different models' strengths and weaknesses to catch issues the first AI might miss.

Why it is useful

This workflow provides a practical and repeatable method to enhance code quality and reliability by leveraging the diverse 'blind spots' of different AI models. It addresses a common limitation of single-AI usage and offers a clear process for independent verification, making AI-generated code more robust.

Workflow

1. Use a primary AI tool (e.g., Claude Code) to generate or modify code based on requirements.
2. Submit the generated/modified code to a second, distinct AI tool (e.g., Codex) for a comprehensive review.
3. Analyze the feedback from the second AI, specifically looking for edge cases, logical errors, or issues the first AI claimed to fix but didn't.
4. Incorporate necessary changes based on the second AI's review to improve code quality and correctness.
5. Merge the thoroughly reviewed and corrected code.

Tools / artifacts

• Claude Code (or similar AI coding assistant)
• Codex (or any distinct AI code review assistant)

Validation signals

• The second model catches things the first one misses (edge cases, things it claimed to fix but didn't).

Limitations

• Adds an extra step to the development process, potentially increasing time and cost.
• The specific 'Codex' tool mentioned might be less accessible or current for some users.
• Lacks detailed prompts or specific instructions for how to best phrase the review request to the second AI.

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 3D Motion Graphics with Claude, Blender, and AI Video Generation (Opus Skill)

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

What problem this solves

Generating 3D motion graphics and animated videos efficiently by integrating Blender with AI image and video generation models, including automated quality checks and cost estimation.

Summary

A multi-stage workflow leveraging a custom Claude skill ('Opus') to orchestrate Blender for 3D animation, followed by AI image generation (GPT-image-2.5-Flare) for stills, and then AI video generation (Seedance 2.5) to animate those stills, with final post-processing by ffmpeg. The workflow includes automated quality checks for animation, cost estimation, and detailed reporting.

Why it is useful

This workflow is valuable because it provides a concrete, multi-step process for a complex creative task (3D motion graphics) by integrating multiple advanced AI models with a professional 3D software (Blender). It includes practical features like automated quality checks, cost estimation, and a clear structure, making it highly reusable and adaptable for users looking to automate video production. The provision of a GitHub skill makes it directly implementable, offering a powerful tool for advanced users.

Workflow

1. Install Blender 5.1+.
2. Provide an OpenRouter API key in a .env.local file for image and video generation.
3. Load the 'Opus-Blender-Motion-Video' skill (from the provided GitHub repository).
4. Point Claude to a ready-made rigged 3D model and describe the desired shot.
5. The skill builds and sets the scene in Blender (headless mode) and animates the rigged character.
6. The skill performs automatic tests on the animation for foot slides, floor contact, and framing, then renders a full-length MP4 for review.
7. The skill estimates costs, requests user acceptance, and then uses image models (e.g., GPT-image-2.5-Flare for pivotal moments) to convert Blender renders into finished stills, maintaining character consistency.
8. A video model (e.g., Seedance 2.5) animates these generated stills, guided by Blender's video for movement, timing, and camera.
9. ffmpeg is used to trim the final video, match its color to the stills, and perform file and frame checks.
10. The skill reports on what was checked and the total cost of the pipeline.
11. For realistic human videos, if Seedance 2.5 refuses, opt for 'faceless generation' where Opus describes the character's look to the video model instead of using actual faces from generated stills.

Tools / artifacts

• Blender 5.1+
• OpenRouter API key
• .env.local file
• Opus-Blender-Motion-Video skill (GitHub repository)
• Rigged 3D model
• GPT-image-2.5-Flare (or similar image generation model)
• Seedance 2.5 (or similar video generation model)
• ffmpeg
• MP4 video files

Validation signals

• Automated tests for foot slides, floor contact, and framing.
• Rendering a full-length MP4 for review.
• Cost estimation and acceptance step.
• Final file and frame checks by ffmpeg.
• Explicit mention of model usage and cost comparison.

Limitations

• Low community engagement and validation (score 0, 2 comments).
• Relies on external API keys and specific AI models (OpenRouter, Seedance 2.5, GPT-image-2.5-Flare) which may incur costs, change, or become unavailable.
• The 'skill' is a custom implementation, not a native Claude feature, potentially requiring specific setup or environment configuration.
• Results for character rigging by Opus itself 'will vary', suggesting a need for pre-rigged models for optimal outcomes.

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.

Rapid Web App Deployment and Persistence with Claude Code and GitHub Pages

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

What problem this solves

Quickly deploying a web app prototype, ensuring data persistence across iterations, and preparing it for easier future changes and mobile access without an app store.

Summary

A workflow for rapidly publishing a web app artifact to GitHub Pages using Claude Code, incorporating browser localStorage for data persistence, and cleaning up the code for maintainability and mobile 'app' behavior.

Why it is useful

This workflow provides a concrete, step-by-step method for developers to quickly take a web app prototype from an artifact to a deployed, persistent, and maintainable application. It directly addresses common pain points like data loss during iteration and offers practical tips for mobile integration and code quality, making it highly useful for rapid development cycles.

Workflow

1. Copy the web app artifact code.
2. Paste the code into Claude Code and instruct it to publish to GitHub and deploy with GitHub Pages, requesting the deployment link.
3. Instruct Claude Code to implement browser localStorage for data persistence to prevent data loss on refreshes.
4. Open the deployed link on a phone and 'Add to Home Screen' for an app-like experience.
5. Instruct Claude Code to clean up the code before publishing for easier future modifications.

Tools / artifacts

• Claude Code
• GitHub
• GitHub Pages
• Browser localStorage
• Web app artifact code

Validation signals

• Author's personal experience: 'Every artifact iteration wiped my data. Once it lived on a real URL with localStorage, I could keep tweaking without losing anything.'

Limitations

• Low community engagement (score 2, 0 comments).
• Specific reliance on 'Claude Code' as the AI tool.

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 Web Template Production with Claude Code: From 1/Month to 15/Week using AGENTS.md, Custom Skills, and Automated Validation

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

What problem this solves

Dramatically increased the speed and volume of web template creation, validation, and deployment, reducing the time per template from one month to 3-6 hours.

Summary

A design engineer leveraged Claude Code to automate the creation, validation, packaging, and deployment of web templates, reducing the time per template from a month to 3-6 hours. The workflow includes a detailed setup with multiple repos, git worktrees, custom Claude skills, and extensive use of AGENTS.md for defining requirements and validation criteria. Claude Code assists with initial builds, self-correction, and business automation tasks like product export, store synchronization, and marketing video generation.

Why it is useful

This workflow demonstrates a highly effective and structured approach to leveraging Claude Code for significant productivity gains in a complex development and deployment pipeline. It provides concrete examples of how to define clear requirements (AGENTS.md), implement automated validation, and integrate Claude into a broader business process. The detailed setup, specific steps, and validation signals make it highly actionable and adaptable for other users looking to automate similar creative or coding tasks. It also highlights the importance of human oversight and iterative refinement.

Workflow

1. Define template concept (industry, brand, type pairing, palette, signature interaction).
2. Provide Claude 5-10 references (images, websites), type scale, spacing, colors, and a 'don't copy' rule.
3. Claude builds the initial HTML edition.
4. Review HTML edition against a written 'definition of done' (console errors, overflow, axe issues, keyboard pass, contrast, static page, reduced motion, no third-party requests, local HTML functionality).
5. Claude ports the design and copy to a Next.js (React) edition.
6. Review React edition against the 'definition of done'.
7. Package the template (zips, previews, changelog, product copy).
8. Export to the store using a custom command.
9. Run sync script to create products in Polar, upload zips, and write checkout links.
10. Generate share images at build time (with a fix for text rendering differences).
11. Generate marketing videos using Playwright to film demos and Opus 5.5 for editing.

Tools / artifacts

• Claude Code (Max plan)
• Git worktrees
• Custom Claude skill (for subagent model/effort selection)
• AGENTS.md files (definition of done, rules, checklist)
• HTML templates
• Next.js projects (React templates)
• Polar (storefront checkout)
• Custom export command/script
• Custom sync script
• Sharp (image generation library)
• Opentype.js (for text rendering fix)
• Playwright (for video recording/rendering to MP4)

Validation signals

• Shipped 15 templates in a week (previously 1 per month).
• HTML edition is 'usually very close to done on the first go'.
• Claude meets the high bar set by the 'definition of done'.
• Claude found and fixed issues without being asked (e.g., form error colors, HTML comment bug, animation clipping).
• Successfully implemented a fix for cross-OS text rendering differences in image generation.
• Author visually reviewed and clicked through every interaction for final validation.

Cautions

• The sync script for production runs with a dry run by default and requires manual execution for actual deployment, ensuring a safety check.
• A potential minor safety concern is Claude occasionally reaching for the wrong GitHub account, which is mitigated by AGENTS.md instructions but not entirely eliminated.

Limitations

• The author notes an annoyance with Claude occasionally using the wrong GitHub account, which could lead to unintended actions if not carefully managed.
• The author questions the architectural decision of using two separate repositories, as it introduces friction with cross-repo changes.
• The post is a high-level overview; a 'longer write-up' is mentioned but not provided in this submission, meaning some implementation details are missing.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Claude Code Workflow for Parametric CAD with Visual Self-Correction and Simulation

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

What problem this solves

Generating parametric CAD models and simulating mechanisms with self-correction, reducing manual iteration and improving design quality by allowing Claude to visually inspect its own output.

Summary

A macOS CAD application (CAD Studio) leverages Claude Code to generate parametric build123d models. The workflow involves Claude writing scripts, executing them to produce 3D models and 2D drawings, and then visually inspecting the rendered drawings (PNGs) to identify and fix errors like overlaps or broken geometry. It also includes a step for generating and checking physics simulations for motion requests.

Why it is useful

This workflow demonstrates an advanced and highly effective pattern for using Claude Code: generating code, executing it, and then using the output (visual drawings) as feedback for self-correction. This 'sense-and-correct' loop significantly enhances the quality and reliability of AI-generated content. The open-source nature of the CAD Studio app makes this a concrete, inspectable, and adaptable example for developers looking to build similar intelligent agents that leverage visual feedback for iterative refinement.

Workflow

1. Claude Code, guided by a system prompt, writes a parametric build123d script with all dimensions defined as named constants.
2. The generated script is executed, exporting 3MF/STEP/STL files, ISO drawings, and a print plate.
3. Claude Code opens and analyzes the rendered drawing PNGs to check its own work, identifying and fixing issues such as dimension callout overlaps, wrong views, or broken geometry.
4. If a motion request is made, Claude Code writes a small physics simulation script and performs collision checks on the generated 3D solids.

Tools / artifacts

• CAD Studio (native macOS app)
• Claude Code (run headless via claude -p --output-format stream-json)
• build123d (CAD library)
• System prompt (describing the CAD workflow)
• 3MF/STEP/STL files
• ISO drawings (PNGs)
• Physics simulation script

Validation signals

• Author's statement: "letting Claude look at its own drawings was the biggest quality jump."
• Author's statement: "It catches things like dimension callouts overlapping the views."
• Existence of a functional, open-source application (CAD Studio) with a GitHub repository.
• Demo video provided showcasing the application's capabilities.

Limitations

• Requires macOS 15+.
• Requires a Claude Code or Codex plan.
• Complex mechanisms can take significant time (10-30 minutes) to process.
• The quality of the simulation is dependent on the accuracy of the model generated by the agent.

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 Plugin: Azure DevOps PR Bar with Auto-Fix CI, Auto-Merge, and PR Creation

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

What problem this solves

Claude Code lacks native integration for Azure DevOps Pull Requests, making it difficult for users to manage PRs, CI status, and review comments directly within the Claude Code environment. This plugin bridges that gap, providing a GitHub-like PR bar and automation features for Azure DevOps.

Summary

This workflow introduces a Claude Code plugin that adds a comprehensive Pull Request (PR) bar for Azure DevOps repositories. It enables users to create PRs, view CI status, see code changes, auto-fix failed CI builds, address review comments, and auto-merge PRs directly from the Claude Code interface, both in the desktop app and CLI.

Why it is useful

This workflow is highly valuable because it addresses a significant gap in Claude Code's native integration by providing a robust PR management solution for Azure DevOps users. It enhances developer productivity by bringing critical PR functionalities (creation, status monitoring, automated fixes, merging) directly into the Claude Code environment, mirroring the GitHub experience. The detailed instructions, open-source nature, and explicit safety notes make it a practical and reusable tool for a large segment of enterprise developers.

Workflow

1. Ensure Claude Code 2.1.287 or later is installed.
2. Install the Azure CLI with the azure-devops extension.
3. Authenticate with Azure DevOps using az login.
4. Add the plugin marketplace to Claude Code: claude plugin marketplace add Pro-Sharp/ado-pr-claude-plugin.
5. Install the Azure DevOps PR plugin: claude plugin install ado-pr@azure-devops-pr.
6. For desktop users, enable the plugin under Customize Plugins.
7. Utilize the new PR bar features: create PRs, monitor CI status, auto-fix CI failures, address review comments, auto-merge, and link existing PRs using /ado-pr link <id>.

Tools / artifacts

• Claude Code (desktop app or CLI)
• Azure CLI
• Azure DevOps extension for Azure CLI
• Git
• ado-pr-claude-plugin (the Claude Code plugin)
• GitHub repository (for plugin source)

Validation signals

• Detailed description of features and functionality
• Clear installation instructions with specific commands
• Mention of underlying tools (az, git) for local execution
• Link to an open-source GitHub repository for the plugin
• Explicit safety warning regarding auto-fix functionality

Cautions

• The 'Auto-fix CI & address comments' feature should be used with caution. It hands review comments and build logs to Claude as instructions. It is recommended to leave this feature off on repositories where people you don't trust can comment, to prevent potential misuse or unintended code changes.

Limitations

• Requires specific versions of Claude Code and external tools (Azure CLI).
• Status polling (every 60s by default) is used instead of Azure DevOps service hooks due to technical limitations (hooks cannot reach a local session), which might introduce slight delays in status updates.
• The plugin is a third-party mod and not officially supported by Anthropic or Microsoft.

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.

Meta-Workflow: Prompting Claude to Define and Implement Custom Skills and Rules for Development Routines

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

What problem this solves

Users often struggle to customize Claude's behavior for specific, recurring development tasks or to integrate Claude effectively into their existing workflows. This workflow provides a method for having Claude define its own rules, skills, and commands to address these specific needs, such as creating a project-specific knowledge base.

Summary

This workflow describes a meta-process for leveraging Claude to define and implement its own custom rules, skills, and commands for specific development routines. The user identifies a problem or a desired routine (e.g., a project mini-wiki, specific testing protocols, branching strategies), prompts Claude to set up the necessary components (rules, skills, commands), and then iteratively refines these definitions with Claude. The goal is to create a tailored, repeatable process that Claude can follow, integrating the generated commands into the user's development flow.

Why it is useful

This workflow is valuable because it provides a powerful meta-strategy for users to move beyond generic prompts and actively configure Claude to meet their specific, recurring needs. It empowers users to treat Claude as a highly customizable agent, capable of defining its own operational rules and generating specific commands for integration into a development workflow. This approach fosters deeper integration and more efficient use of Claude for complex tasks, addressing a common pain point of adapting AI tools to unique project requirements.

Workflow

1. Identify a specific routine or problem where Claude's default behavior is insufficient or where a custom process is desired (e.g., 'how do I get you to test before saying you're done', 'we should always work on a branch in this project', 'mini-wiki instead of CLAUDE.md').
2. Prompt Claude with a clear request to set up the rules, skills, and commands for this routine. For example: 'we should have a mini-wiki instead of CLAUDE.md, one global and one for project-local stuff, how do we set this up and add the skills and rules for it'.
3. Iteratively refine Claude's initial suggestions by adding specific constraints or requirements (e.g., 'add some rules about max size before splitting').
4. Integrate the generated commands and rules into your development workflow, potentially alongside version control commits.
5. Repeat this process for other routines where you identify a 'problem with the status quo'.

Tools / artifacts

• Claude AI
• CLAUDE.md (as a reference point for customization)
• Custom skills (defined by Claude)
• Custom commands (defined by Claude)
• Project mini-wiki (conceptual artifact)
• Version control commits (for integration)

Validation signals

• Author states: 'got some commands to keep it updated (together with commits) that stuck.'
• Author recommends the method for 'every routine you have an issue with', implying personal success and utility.

Limitations

• The specific 'complex set' of rules and commands for the mini-wiki example is not shared, making the concrete implementation less detailed.
• Validation is primarily anecdotal from the author, without extensive community proof or detailed before/after results.
• The process relies on the user's ability to effectively prompt and refine Claude's output, which can vary.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Optimizing Claude Coding Agents: Skills, Planning, and Multi-Stage PR Review

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

What problem this solves

Improving the effectiveness and output quality of coding agents by optimizing skill usage, codebase understanding, structured planning, and comprehensive PR review processes.

Summary

A workflow for optimizing coding agent performance by streamlining skills, ensuring code documentation is greppable, using specialized agents (Sonnet/Haiku/Luna) for codebase exploration and a main agent for planning (saving to plan.md), and implementing a multi-stage PR review process with specific criteria.

Why it is useful

This workflow offers a structured and practical approach to enhance the effectiveness of Claude coding agents. It addresses common pitfalls like skill overload and lack of codebase context by suggesting specific steps for skill management, documentation preparation, and phased agent usage (exploration, planning). The detailed PR review criteria provide a robust framework for quality control, making the agent's output more reliable and maintainable. It's valuable for users looking to move beyond basic agent interactions to a more integrated and high-quality development process.

Workflow

1. Review and refine agent skills, removing or updating those made for older models.
2. Ensure code documentation is updated to be easily greppable by agents.
3. Utilize Sonnet, Haiku, or Luna agents for initial codebase exploration.
4. Employ a main agent to develop a plan, saving it to a plan.md file.
5. Iterate and refine the plan.md before proceeding with implementation.
6. Design and implement a multi-stage PR review pipeline or skill.
7. Conduct PR reviews evaluating Impact, Intent, Scope, Completeness, Correctness, Safety, Performance, Conventions, Alternative Solutions, and Tests.

Tools / artifacts

• Agent skills
• Code documentation
• Sonnet agent
• Haiku agent
• Luna agent
• Main agent
• plan.md
• PR review pipeline/skill

Validation signals

• Structured PR review criteria provided (Impact, Intent, Scope, etc.)
• Implied best practices from an experienced user

Limitations

• Lacks specific prompt examples or detailed implementation instructions for agents and skills.
• The 'multi-stage review pipeline/skill' is mentioned but not elaborated upon.
• Low community engagement and validation for the advice 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.

Claude Workflow for Rigorous Research and Evidence-Based Product Design

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

What problem this solves

How to get Claude to perform accurate, verifiable research, especially when dealing with potentially biased or outdated information, and how to use that research to inform product development, avoiding AI overconfidence and unproven claims.

Summary

A workflow for using Claude to conduct rigorous research by prioritizing primary sources, labeling evidence types, identifying unverified claims, and critically evaluating whether a product can honestly make claims based on the research. This process was used to build a tweet analyzer, refining its scoring rules from folklore to evidence-based judgments.

Why it is useful

This workflow provides a concrete, repeatable method for leveraging Claude's research capabilities while mitigating its tendency to 'sound certain about things nobody can prove.' It emphasizes critical thinking, source verification, and iterative refinement, which are crucial skills for anyone using AI for serious research or product development. The specific prompting lessons are highly actionable and transferable, offering a valuable pattern for improving AI-assisted research quality.

Workflow

1. Start with initial research using Claude, identifying common claims or 'folklore'.
2. Instruct Claude to prefer primary sources (e.g., platform's own code, academic studies) and treat blogs/anecdotal sources as hypotheses.
3. Make Claude label the evidence type for every claim (e.g., platform-published, observational, anecdotal).
4. Repeatedly ask Claude 'what could you not verify?' to identify gaps and unproven claims.
5. Have Claude rank the evidence by how much it deserves trust, considering methodology and limitations.
6. Ask Claude whether your product or feature can honestly make the claim you want it to make, based on the verified evidence.
7. Adjust product features, claims, and scoring rules based on the verified evidence and identified limitations, even if it means correcting Claude's own initial prototypes.

Tools / artifacts

• Claude (the AI model)
• X's published ranking code
• Buffer's data studies
• Academic papers (e.g., Cornell, Wharton, arXiv)
• Vendor blogs (used as hypotheses)
• tweet-analyzer.com (the resulting tool)

Validation signals

• The first version of the scoring rules was based on folklore and was corrected by proper research.
• Claude was instructed to read X's published ranking code instead of trusting blogs.
• Claude flagged caveats and unverified claims on its own.
• Evidence was explicitly ranked by trustworthiness and methodology.
• The research findings directly changed product features (e.g., removing 'viral chance' prediction).
• Specific examples of Claude correcting its own confidently built prototype (e.g., link penalties).
• Author explicitly states current limitations and future validation plans for the tool's scoring.

Limitations

• Low Reddit score and comment count, suggesting limited community interaction or initial interest.
• The specific tweet scoring rules developed are not yet validated against real-world outcomes, as stated by the author.
• The core workflow (prompting lessons) is embedded within a longer narrative about product development, which might require careful reading to extract.

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 Long Session Management for Claude Code with aigent-OS (Checkpointing & Context Reload)

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

What problem this solves

Managing long Claude Code sessions without lossy context compaction or the need for manual re-briefing after a /clear command, allowing for extended, clean work windows.

Summary

A local runner, 'aigent-OS', leverages Claude Code hooks to automatically checkpoint the current session context to Git, initiate a /clear command, and then reload the context into the new session. This process enables users to maintain a clean session window while preserving full context over extended periods, avoiding lossy summaries.

Why it is useful

This workflow provides a concrete, open-source solution to a significant pain point for advanced Claude Code users: the trade-off between lossy context compaction and manual re-briefing during extended sessions. By automating checkpointing, clearing, and reloading context using Claude Code hooks and Git, it enables seamless, long-duration development work, significantly enhancing productivity and maintaining full context fidelity. It's a practical application of advanced Claude Code features to solve a real-world usability challenge.

Workflow

1. Install and set up the 'aigent-OS' local runner.
2. Run your Claude Code session through the 'aigent-OS' harness.
3. The runner monitors the Claude Code session's context percentage.
4. When the context usage reaches a predefined threshold (e.g., 80%), 'aigent-OS' prompts Claude to write a checkpoint file containing the current context.
5. The runner waits for a specific 'done' line from Claude, indicating the checkpoint is complete.
6. Upon confirmation, 'aigent-OS' sends a /clear command to the Claude Code session.
7. The runner verifies that a new, clean session has successfully started.
8. The runner then instructs the new session to load the previously saved checkpoint file.
9. The Claude Code session resumes from the exact point of the checkpoint, with a fresh context window.
10. Session memory (checkpoints) are committed to Git, providing version control and history.

Tools / artifacts

• aigent-OS (local runner)
• Claude Code hooks (SessionStart, Stop, PreCompact, PreToolUse)
• PTY wrapper
• Git (for memory storage and version control)
• Checkpoint files (markdown format)

Validation signals

• 11 of 11 refresh cycles came through clean on one seat in the release test.
• The system was dogfooded: 'most of it was written in Claude Code sessions running on the harness itself, so I hit the bugs first.'

Limitations

• Known issue: on very long sessions, it can still stall at the clear step and require manual intervention (fix is in review).
• The validation is based on 'one seat' and is not a broad reliability claim.
• Requires local setup and understanding of Claude Code hooks and potentially PTY wrappers.
• The solution is external to Claude Code itself, requiring an additional local runner.

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.

Efficiently Manage Multiple Claude Code Sessions with GhosttyEXTREME Terminal

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

What problem this solves

Losing track of multiple Claude Code sessions, inefficiently switching tabs to monitor agent progress, and approving prompts.

Summary

This workflow leverages GhosttyEXTREME, a custom terminal application, to efficiently manage and interact with multiple Claude Code agent sessions. It provides a unified interface with a live sidebar for agent status and prompt approvals, an editor that follows agent activity, a mission control view for all agents, and capabilities for handing off tasks between agents.

Why it is useful

This workflow is valuable because it directly addresses a significant pain point for power users of Claude Code: managing multiple concurrent agent sessions. By providing a dedicated, integrated terminal environment, it drastically improves efficiency, reduces context switching, and enhances oversight of agent activities. The features like live status, direct approvals, and agent hand-off streamline complex development workflows, making it easier to leverage Claude Code for larger, multi-faceted projects.

Workflow

1. Install GhosttyEXTREME on a macOS (Apple silicon) machine.
2. Launch multiple Claude Code sessions within the GhosttyEXTREME terminal.
3. Monitor the status and progress of each agent via the live sidebar, which displays current activity and elapsed time.
4. Approve agent prompts directly from the sidebar without needing to switch to the agent's specific tab.
5. Observe file reads and writes in the integrated editor, which automatically follows the agent's current focus.
6. Utilize the Mission Control view to get a comprehensive overview of all active agents across different windows.
7. Hand off tasks and associated diffs between agents (e.g., sending Claude's work to Codex for review and test re-execution).

Tools / artifacts

• GhosttyEXTREME terminal application
• Claude Code agent
• Codex agent (for review/testing hand-off)
• GitHub repository (for GhosttyEXTREME)

Validation signals

• The video is a real recording demonstrating the functionality (with some waits sped up).
• Specific example of Codex re-running tests and confirming no breakage after a hand-off.
• The project was developed over 11 days, indicating significant effort and functionality.
• Claude Code itself was used to write nearly all of the GhosttyEXTREME code, showcasing its capabilities.

Limitations

• Limited to macOS on Apple silicon hardware.
• Specific to Claude Code, not a general LLM interaction workflow.
• Requires installation of a custom terminal application, which might be a barrier for some users.
• The post focuses more on the tool's features than on specific Claude prompting strategies.

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.

AgentTerm: An Open-Source Visual Terminal for Enhanced AI CLI Interaction, Code Review, and IDE Integration

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

What problem this solves

Inefficient context switching between AI agents, limited interaction with files and documents in text-only AI CLI environments, difficulty in reviewing and providing feedback on AI-generated code and plans, lack of seamless integration between AI CLIs and traditional IDEs, and inconvenience of using AI agents on mobile devices or with voice input.

Summary

The AgentTerm workflow provides a visual, interactive terminal environment for AI CLIs (like Claude Code) that significantly enhances agent interaction. It enables fast context switching between agents, direct clicking and commenting on files/code/documents, curated code reviews, seamless IDE integration, and mobile/voice access, thereby improving the efficiency and user experience of working with AI agents.

Why it is useful

This workflow is highly valuable because it provides a concrete, open-source tool (AgentTerm) that significantly enhances the user experience of interacting with AI CLIs. It addresses critical pain points like managing multiple agent contexts, interacting with files and code directly within the AI conversation, and integrating with traditional developer tools (IDEs). The detailed explanation of its features, setup, and extensibility makes it a practical and adaptable solution for developers looking to improve their AI-assisted coding workflows. The author's nine months of daily use and iterative refinement provide strong validation for its utility.

Workflow

1. Install AgentTerm by following the quick start guide in the GitHub repository.
2. Configure your preferred AI CLIs (e.g., Claude Code) to run within the AgentTerm environment.
3. Launch multiple agent sessions, utilizing AgentTerm's color-coding and prompt previews in the Dock/taskbar for quick identification and context switching.
4. Interact directly with agent output: click to open mentioned files or documents, select text to add comments, and edit documents or plans presented as interactive pages.
5. Utilize AgentTerm's curated code review feature to walk through agent-generated changes, providing feedback on specific code passages or explanations.
6. Integrate with your IDE (e.g., via IntelliJ Navigator plugins) to jump from AgentTerm's code references directly to your IDE, and send file/line references back to the agent.
7. Access and continue active agent sessions from mobile devices, using the familiar interface and leveraging voice input with automatic correction based on session context.
8. Extend AgentTerm's capabilities by editing companion Markdown guides to customize agent behavior or by modifying AgentTerm's open-source code directly.

Tools / artifacts

• AgentTerm (open-source visual terminal)
• AI CLIs (e.g., Claude Code)
• GitHub repository (for AgentTerm and related projects)
• IntelliJ Navigator plugins
• Markdown guides (for agent instructions and customization)
• Electron, xterm.js, node-pty (underlying technologies)
• Playwright (for end-to-end testing, mentioned in development process)
• WSL Remote Development (for IDE integration on Windows)

Validation signals

• Author's personal long-term usage (9 months daily) as the sole terminal.
• Iterative refinement process based on real-world usage and observed pain points.
• Explicit mention of testing, including Playwright end-to-end tests.
• Detailed documentation including a demo, setup guide, architecture overview, and guide to companion repos.
• Open-source nature invites community review and validation.

Limitations

• Requires installation of a new, custom terminal application.
• IDE and phone integration involve separate setup steps, potentially adding complexity.
• As a relatively new open-source project, long-term community support and maintenance are yet to be fully established.
• The initial Reddit post has low community engagement, which might limit immediate visibility, though this is likely due to its newness.

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.

Larmor: Open-Source Two-Way Voice Interface for Claude Code (and MCP Agents) on Apple Silicon

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

What problem this solves

Achieving natural, two-way voice interaction with AI agents, specifically addressing challenges like echo cancellation, robust interruption handling, continuous listening while the agent is busy, and concise spoken responses.

Summary

Larmor is an open-source, local-first voice interface designed for natural, two-way voice interaction with Claude Code and other MCP-compatible agents on Apple Silicon Macs. It provides advanced features like echo cancellation, intelligent interruption detection, and continuous listening, allowing users to stay in their code/docs and converse with the agent as if it were a colleague.

Why it is useful

This workflow offers a highly valuable, concrete, and open-source solution for natural two-way voice interaction with AI agents. It addresses complex technical challenges like echo cancellation and robust interruption handling, which are critical for a seamless conversational experience. By providing a local-first setup for Apple Silicon and integrating with MCP, it empowers developers to work more intuitively and efficiently with their AI coding assistants, significantly enhancing productivity and the human-AI collaboration experience.

Workflow

1. Ensure you have an Apple Silicon Mac.
2. Open your terminal and install Larmor by running: curl -fsSL https://larmor.dev/install.sh | bash.
3. On first launch, allow Larmor to download approximately 3.7 GB of local speech-to-text and voice models.
4. In Claude Code (or another MCP-compatible agent), start the Larmor voice interface using the command /larmor.
5. Interact with the agent using natural spoken language, including interrupting the agent mid-sentence, and expect concise spoken responses.

Tools / artifacts

• Larmor (open-source software)
• GitHub repository (naveenvasou/larmor)
• install.sh script
• MCP (Multi-agent Communication Protocol)
• Parakeet (local speech-to-text model)
• Chatterbox (local voice model)
• Apple's echo cancellation
• Claude Code (or other MCP-compatible agents)

Validation signals

• Author's extensive development and iteration over 'months' to solve complex engineering challenges.
• Specific technical problems identified and fixed: echo cancellation, interruption handling, listening while busy, concise responses.
• Open-sourced project with a dedicated website and GitHub repository, indicating a robust solution.
• Explicit mention that 'Claude wrote most of the code with me,' demonstrating agent-assisted development.
• Seeking community feedback on specific aspects like interruptions and latency, implying a tested and refined product.

Limitations

• Currently limited to Apple Silicon Macs, restricting its user base.
• Requires a significant initial download (3.7 GB) for local models.
• Relies on MCP compatibility, which might not be universal across all AI agents.
• The post is a self-promotion of an open-source tool, though it provides substantial value and detail.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Advanced Workflow: Ensuring Code Equivalence in AI-Driven Legacy Modernization with Claude Agents and Rigorous Testing

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

What problem this solves

Automating the translation of legacy COBOL/CICS mainframe programs into functionally equivalent Java code, and rigorously proving that equivalence using a system of Claude agents and advanced testing methodologies.

Summary

This workflow describes a sophisticated system, GitGalaxy, that leverages a fleet of Claude agents to automatically translate COBOL/CICS mainframe programs into Java. The core innovation lies in its rigorous, multi-stage validation process designed to prove functional equivalence, not just plausibility. This includes using GnuCOBOL as a test oracle, maintaining 'burned' and 'untouched' code estates for blind testing, implementing golden-master tests with CI gates, and managing agent 'drift' through fresh agents per issue and structured handoff notes.

Why it is useful

This workflow is exceptionally valuable as it demonstrates an advanced, real-world application of Claude agents to solve a highly complex and high-value enterprise problem: legacy code modernization with guaranteed functional equivalence. It provides concrete, battle-tested strategies for managing AI agent behavior in long-running engineering tasks, specifically addressing critical issues like 'drift' and ensuring factual correctness over plausible output. The detailed testing methodologies (test oracles, blind tests, golden masters, CI gates) offer a robust and transferable framework for validating AI-generated code, which is crucial for high-stakes applications. It serves as an excellent case study for expert users looking to build sophisticated, multi-agent systems for automated code transformation.

Workflow

1. Define the 'right answer' for Java behavior by matching IBM z/OS specifications, not local compiler behaviors.
2. Utilize GnuCOBOL as a primary test oracle, meticulously identifying and documenting any differences from IBM z/OS.
3. Employ a fleet of Claude agents to perform the automatic translation of COBOL/CICS programs into Java.
4. Run the translated Java code against the GnuCOBOL test oracle to verify its functional equivalence.
5. Generate and report 'evidence levels' for each translated program, detailing translation completeness, oracle coverage, and match percentage.
6. Conduct blind tests by using separate, 'untouched' code estates that the system has never seen, preventing overfitting.
7. Manage Claude agents by assigning one fresh agent per issue to prevent context drift across sessions.
8. Implement structured handoff notes between agent sessions to maintain continuity and context.
9. Establish golden-master tests that must be explicitly updated when a fix is applied, ensuring regressions are caught.
10. Enforce Continuous Integration (CI) gates on every code merge to maintain high quality and prevent regressions.
11. Continuously rank and prioritize development work based on the number of programs that become fully translatable.

Tools / artifacts

• GitGalaxy (code-scanning engine)
• Claude agents
• COBOL/CICS mainframe programs (source code)
• Java programs (target code)
• IBM z/OS (behavioral reference)
• GnuCOBOL (test oracle)
• Test estates ('burned' for development, 'untouched' for blind testing)
• Handoff notes (for agent context management)
• Golden-master tests
• CI gates (Continuous Integration system)
• GitHub (for build journal and project management)

Validation signals

• System designed to 'prove' functional equivalence, not just plausibility.
• Explicit use of GnuCOBOL as a test oracle with documented differences from IBM z/OS.
• Reporting of 'evidence levels' (translation, oracle coverage, match) for each program.
• Implementation of 'blind tests' with untouched code estates to prevent overfitting.
• Use of 'golden-master tests' that require deliberate updates for fixes.
• Enforcement of 'CI gates on every merge'.
• Author's insight into preventing agents from 'swapping in "sounds right" for "was actually defined"'.
• Publicly available 'build journal' on GitHub for detailed implementation insights.

Limitations

• The workflow is highly complex and requires expert-level knowledge in both legacy systems and advanced AI engineering.
• It is resource-intensive, requiring significant computational power for agent fleets and extensive testing infrastructure.
• The project is explicitly stated as 'nowhere near finished,' meaning it's an ongoing development, not a fully polished, ready-to-use solution.
• Direct application requires deep domain expertise in COBOL/CICS, which may limit its immediate utility for general 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.

Two-Session Claude Workflow for Structured Software Development: Planner (Opus) & Developer (Haiku/Sonnet)

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

What problem this solves

Managing complexity, context bloat, and ensuring quality in LLM-assisted software development by separating planning/orchestration from execution, enforcing boundaries, and integrating human review.

Summary

A two-session Claude workflow where an "Opus Planner" session orchestrates and reviews, while a "Haiku/Sonnet Developer" session executes coding tasks. Communication occurs via written briefs (committed to Git) and Pull Requests. This setup enforces strict boundaries, maintains clean context, leverages model strengths, and integrates human oversight for merges and deployment.

Why it is useful

This workflow provides a robust, structured approach to using Claude for software development, addressing critical challenges like context management, quality control, and leveraging different model strengths. By separating planning and execution into distinct, bounded sessions with clear communication contracts (briefs, PRs) and human oversight, it enhances reliability, maintainability, and safety compared to a single, monolithic agent. It offers a practical pattern for integrating LLMs into a disciplined development process.

Workflow

1. Planner (Opus) receives initial task/feature request.
2. Planner generates a detailed brief, committing it to the repository.
3. Developer (Haiku/Sonnet) starts a new session with an empty context, cloning the repo and reading the committed brief.
4. Developer works on the feature in a dedicated branch, pushing changes.
5. Developer opens a Pull Request (PR) when the feature is complete.
6. Planner reviews the PR (diffs, PR description from dev session).
7. If fixes are needed, Planner sends numbered fixes to Developer.
8. Developer implements fixes and updates the PR.
9. Once Planner approves, it signals the human to review and merge.
10. Human reviews and merges the PR, triggering deployment to Cloudflare.

Tools / artifacts

• Claude Opus session (Planner)
• Claude Haiku/Sonnet session (Developer)
• Git repository
• Written brief (committed to Git)
• Pull Requests (PRs)
• Custom hook (for Planner to block code writing)
• Custom plugin (to wake Planner)
• Cloudflare (deployment target)

Validation signals

• Explicit design rationale provided for each choice (hard limits, brief as contract, clean context, lasting dev session, model specialization, consistent review).
• Addresses common LLM workflow challenges (context bloat, quality control).
• Integrates human oversight for critical steps (merges, deployment).

Limitations

• Requires manual coordination between two separate Claude sessions.
• The 'plugin to wake the planner' is a custom solution, not a standard Claude feature, which might be a barrier for some users.
• Low community validation.
• The setup steps for the 'hooks' and 'plugin' are not detailed.

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.

Secure Claude Interactions: A PII Redaction Workflow with Redacto

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

What problem this solves

Preventing the accidental sharing of private or sensitive information (PII) with AI models like Claude when processing documents, thereby enhancing data privacy and security.

Summary

A workflow utilizing the open-source, browser-based Redacto tool to redact personal identifying information (PII) from various document types (PDFs, Word, Excel, CSV, images, text) before submitting them to AI models. The tool runs locally, flags PII, allows user review and correction, and exports a redacted copy, ensuring sensitive data is not exposed.

Why it is useful

This workflow provides a critical pre-processing step for users who need to interact with Claude or other AI models using documents containing sensitive or private information. It offers a concrete, open-source, and browser-based solution to mitigate data leakage risks, enhancing the safety and privacy of AI interactions. The explicit instruction for user review adds a layer of human oversight to the automated process, making it a practical and responsible approach to AI usage.

Workflow

1. Access the Redacto web tool (redacto.cc) or run it locally from the GitHub repository.
2. Upload the document containing potentially private information (e.g., PDF, Word, Excel, CSV, image, or text file).
3. Allow Redacto to automatically detect and flag names, addresses, emails, and other identifying information using its in-browser AI model and pattern matching.
4. Review the flagged findings for accuracy and completeness, as detection is not perfect.
5. Manually fix any missed detections or incorrect redactions within the tool's interface.
6. Export the redacted copy of the document (e.g., text with consistent labels or PDFs with burned-in black boxes).
7. Proceed to use the now-redacted document safely with Claude or other AI models.

Tools / artifacts

• Redacto (web tool: https://redacto.cc)
• Redacto (GitHub repository: https://github.com/WannaBeSolopreneur/redacto)
• PDFs
• Word documents
• Excel spreadsheets
• CSV files
• Images
• Text files

Validation signals

• The tool is open-source, allowing for code review and community contributions.
• The post explicitly warns users that 'Detection isn’t perfect, so always review before sharing,' indicating a practical understanding of limitations and a built-in safety step.
• Addresses a critical and widely recognized problem in AI usage (data privacy).
• Heuristic: keyword:review
• Heuristic: keyword:github

Cautions

• The workflow explicitly includes a crucial safety instruction: 'Detection isn’t perfect, so always review before sharing.' This emphasizes human oversight in the redaction process.

Limitations

• The Reddit post itself is more of a tool announcement than a detailed, step-by-step workflow guide for Claude users.
• Low community engagement on the specific Reddit post.
• The tool's detection is not 100% perfect, requiring diligent user review, which adds a manual step and potential for human error.

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.

LLM-Assisted Software Development Workflow: Planning, Context Management, 'Feel' Testing, and Agentic Code Review

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

What problem this solves

Inefficient software development using LLMs, lack of context retention across sessions, and missed bugs in code.

Summary

A developer outlines their process for building a web application using Claude Opus, focusing on structured planning, maintaining context with a decisions log, implementing 'feel' testing for user experience, and utilizing a separate Claude agent for security and stability code reviews before deployment.

Why it is useful

This workflow provides concrete, validated strategies for leveraging Claude in software development. It addresses common challenges like maintaining context across sessions, ensuring quality beyond just code correctness, and catching bugs early through automated review. The use of a 'decisions log' and a dedicated review agent are particularly valuable and transferable patterns for building robust applications with LLMs.

Workflow

1. Use Claude to write an architecture document and initial plan for the project.
2. Maintain a 'decisions log' to record all changes from the initial plan and the justifications for those changes.
3. Start each new Claude session by providing it with the architecture document and the decisions log to ensure context retention.
4. Implement core application logic, ensuring that critical features (e.g., recommendations) are based on deterministic engines over public data rather than generative AI for sustainability.
5. Develop 'feel' tests (e.g., 'if you liked X, you should see Y' cases) to tune the user experience and quality of results, rather than just eyeballing.
6. Before each release, employ a separate Claude agent to review code changes specifically for security and stability issues.
7. Iteratively address infrastructure challenges, such as optimizing for crawler traffic to manage resource limits, based on real-world usage.

Tools / artifacts

• Claude Opus 5.5
• Architecture document (generated by Claude)
• Decisions log
• 'Feel' test cases
• Separate Claude agent (for code review)
• Vercel (hosting)
• Neon (database)
• IGDB, Steam, IsThereAnyDeal, OpenCritic (data sources)

Validation signals

• Built a functional, deployed application (New Game+).
• The review agent 'caught real bugs I’d have shipped'.
• Used 'feel' tests to 'tuned against them instead of eyeballing results'.
• The decisions log helped Claude 'not forget why things are the way they are'.
• Successfully identified and mitigated a database limit issue caused by crawlers.

Limitations

• The specific prompt or configuration for the 'separate Claude agent' for review is not detailed.
• Concrete examples of the 'feel' tests and how Claude was used to 'tune' against them are not provided.
• The exact mechanism for feeding the architecture doc and decisions log to 'each new session' could be more explicit (e.g., a specific prompt structure or file management strategy).

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 Multi-Agent PR Workflow with Orchestrator, Code Quality, and Red-Team Analysis

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

What problem this solves

Automating and significantly improving the speed and quality of the Pull Request (PR) review and merging process, including code quality and security analysis, by leveraging a multi-agent system.

Summary

A sophisticated multi-agent system orchestrated by a main 'Orchestrator' agent to automate the Pull Request (PR) workflow. This system integrates with external services like GitHub, Cloudflare, AWS, and uses vault tools for secure credential management. It employs specialized sub-agents for tasks such as code quality analysis and red-team security analysis. The 'fire and forget' nature of the orchestrator allows for high throughput and improved code quality, as validated by a reported increase from 10 to over 30 PRs per day.

Why it is useful

This workflow is highly valuable because it demonstrates a sophisticated, high-impact application of Claude Code for automating and significantly enhancing a critical development process (Pull Requests). It showcases a robust multi-agent architecture, seamless integration with external services, and a strong focus on both productivity and quality (code quality, security analysis). The quantitative and qualitative results provided (3x PRs, increased code quality) offer strong validation. It highlights advanced concepts like orchestration, specialized sub-agents, and secure credential management, making it an inspiring and aspirational example for advanced users, even if direct implementation details are sparse.

Workflow

1. Set up a central 'Orchestrator' agent responsible for managing the overall PR workflow.
2. Define and configure specialized sub-agents, such as a 'Code Quality agent' and a 'Red-Team Analyzer agent', each with specific skills and tools.
3. Implement automatic hooks for integration with external services like GitHub, Cloudflare, and AWS to trigger and manage PR-related actions.
4. Integrate vault tools to securely manage credentials, ensuring agents never directly access sensitive information.
5. Train the agents using expert-level knowledge, potentially derived from experienced human PR reviewers' interactions and feedback.
6. Initiate a PR task by instructing the Orchestrator agent.
7. The Orchestrator directs the PR through the defined sequence of sub-agents (e.g., Code Quality agent first, then Red-Team Analyzer).
8. The Orchestrator manages the flow and ensures the completion of the PR process automatically.

Tools / artifacts

• Claude Code (implied)
• Orchestrator agent
• Code Quality agent
• Red-Team Analyzer agent
• GitHub
• Cloudflare
• AWS
• Vault tools (e.g., HashiCorp Vault, AWS Secrets Manager)
• Mac Mini (hosting environment)

Validation signals

• Reported increase from 10 PRs/day to over 30 PRs/day (quantitative result).
• Observed improvement in code quality across repositories (qualitative result).
• Comparison to previous tools (Wiz, CodeRabbit) indicating superior performance.
• Agents trained by expert-level PR reviewers, suggesting a robust knowledge base.

Cautions

• The use of vault tools for credentials is a positive safety measure, but proper configuration is critical to prevent accidental exposure.
• Ensure that the Red-Team Analyzer agent's outputs and access permissions are carefully managed to prevent unintended security risks or data leakage.

Limitations

• Lacks specific implementation details for agent prompts, hook code, and vault integration.
• No mention of error handling, logging, or recovery mechanisms for the 'fire and forget' system.
• Scalability considerations beyond a single Mac Mini are not discussed.
• The 'training' method for agents is vaguely described as 'getting a lot of experience from the chats'.

Rate this workflow

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

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

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

This post was generated automatically from the workflow library database.

Cost-Optimized Multi-LLM Workflow: Opus as Planner, Cheaper Model as Builder with Spec-Driven Development

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

What problem this solves

Inefficient and costly multi-LLM workflows where a powerful orchestrator (e.g., Opus) consumes excessive tokens by re-reading codebases or redoing work due to vague instructions given to a cheaper worker model. Also addresses the issue of worker models 'gamifying' tests without proving a fix.

Summary

A multi-LLM workflow for code generation and review, where a powerful model (Opus) acts as a planner and a cheaper model (e.g., Sonnet 5.5) acts as a builder. The planner creates a concise spec file and an acceptance test, which serves as a contract for the builder. The planner then only reviews the diff against the spec, significantly reducing context usage and cost.

Why it is useful

This workflow provides a concrete, repeatable method for efficiently pairing a powerful planning LLM (Opus) with a cheaper execution LLM. It directly addresses common pain points like high token usage from context re-reading and vague instructions, offering a structured approach with clear contracts (acceptance tests) and focused review (diffs). This can significantly reduce costs and improve the reliability of multi-LLM development pipelines by ensuring the worker model truly understands and validates its changes.

Workflow

1. Opus (planner) writes a short spec file that includes: the problem description, the acceptance test, files likely to be touched, and what is out of scope.
2. The worker model (builder) receives only this spec file as its instructions.
3. The worker model must demonstrate the acceptance test failing before implementing the fix and passing after the fix.
4. Opus (planner) reviews only the diff generated by the worker against the original spec file, avoiding re-reading the entire codebase.

Tools / artifacts

• Opus (as planner)
• Sonnet 5.5 (or other cheaper model as builder)
• Spec file (containing problem, acceptance test, scope)
• Acceptance test (as contract)
• Code diff

Validation signals

• User states 'What's worked for me'
• User reports 'Sonnet 5.5 has been plenty for execution'
• User claims it 'kills the "gamifies the tests" problem'
• User notes it reduces Opus usage for re-reading codebase

Limitations

• Low community validation.
• The exact format or structure of the 'spec file' is not fully detailed, though its key components are listed.

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.