By thefjk
Production-grade Claude Code plugin: parallel-fanout PR review, autonomous GitHub issue triage and resolution, brainstorm/plan/execute workflows with wave-based subagent dispatch.
Create a GitHub issue with classification, codebase investigation, duplicate search, and label/scope validation
Comprehensive PR review using specialized agents
Review changed code for reuse, quality, and efficiency, then fix any issues found
Spawn an autonomous Claude agent in a new terminal/cmux workspace to solve a GitHub issue, with auto-triage and tier-appropriate workflow
Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issues, and ensure code follows the established patterns in CLAUDE.md. Also the agent needs to know which files to focus on for the review. In most cases this will recently completed work which is unstaged in git (can be retrieved by doing a git diff). However there can be cases where this is different, make sure to specify this as the agent input when calling the agent. Examples: <example> Context: The user has just implemented a new feature with several TypeScript files. user: "I've added the new authentication feature. Can you check if everything looks good?" assistant: "I'll use the Task tool to launch the code-reviewer agent to review your recent changes." <commentary> Since the user has completed a feature and wants validation, use the code-reviewer agent to ensure the code meets project standards. </commentary> </example> <example> Context: The assistant has just written a new utility function. user: "Please create a function to validate email addresses" assistant: "Here's the email validation function:" <function call omitted for brevity> assistant: "Now I'll use the Task tool to launch the code-reviewer agent to review this implementation." <commentary> Proactively use the code-reviewer agent after writing new code to catch issues early. </commentary> </example> <example> Context: The user is about to create a PR. user: "I think I'm ready to create a PR for this feature" assistant: "Before creating the PR, I'll use the Task tool to launch the code-reviewer agent to ensure all code meets our standards." <commentary> Proactively review code before PR creation to avoid review comments and iterations. </commentary> </example>
Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality. This agent should be triggered automatically after completing a coding task or writing a logical chunk of code. It simplifies code by following project best practices while retaining all functionality. The agent focuses only on recently modified code unless instructed otherwise. Examples: <example> Context: The assistant has just implemented a new feature that adds user authentication to an API endpoint. user: "Please add authentication to the /api/users endpoint" assistant: "I've implemented the authentication for the /api/users endpoint. Here's the code:" <function call omitted for brevity> <commentary> Since a logical chunk of code has been written (authentication feature), use the Task tool to launch the uberdev:code-simplifier agent to improve the code's clarity and maintainability while preserving functionality. </commentary> assistant: "Now let me use the uberdev:code-simplifier agent to refine this implementation for better clarity and maintainability" </example> <example> Context: The assistant has just fixed a bug by adding several conditional checks. user: "Fix the null pointer exception in the data processor" assistant: "I've added the necessary null checks to prevent the exception:" <function call omitted for brevity> <commentary> After modifying code to fix a bug, use the uberdev:code-simplifier agent to ensure the fix follows best practices and maintains code quality. </commentary> assistant: "Let me refine this bug fix using the uberdev:code-simplifier agent to ensure it follows our best practices" </example> <example> Context: The assistant has just refactored a function to improve performance. user: "Optimize the data sorting algorithm for better performance" assistant: "I've optimized the sorting algorithm. Here's the updated implementation:" <function call omitted for brevity> <commentary> After completing a performance optimization task, use the uberdev:code-simplifier agent to ensure the optimized code is also clear and maintainable. </commentary> assistant: "Now I'll use the uberdev:code-simplifier agent to ensure the optimized code is also clear and follows our coding standards" </example>
Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes: (1) After generating large documentation comments or docstrings, (2) Before finalizing a pull request that adds or modifies comments, (3) When reviewing existing comments for potential technical debt or comment rot, (4) When you need to verify that comments accurately reflect the code they describe. <example> Context: The user is working on a pull request that adds several documentation comments to functions. user: "I've added documentation to these functions. Can you check if the comments are accurate?" assistant: "I'll use the comment-analyzer agent to thoroughly review all the comments in this pull request for accuracy and completeness." <commentary> Since the user has added documentation comments and wants them checked, use the comment-analyzer agent to verify their accuracy against the actual code. </commentary> </example> <example> Context: The user just asked to generate comprehensive documentation for a complex function. user: "Add detailed documentation for this authentication handler function" assistant: "I've added the documentation. Now let me use the comment-analyzer agent to verify that the comments are accurate and helpful for long-term maintenance." <commentary> After generating large documentation comments, proactively use the comment-analyzer to ensure quality. </commentary> </example> <example> Context: The user is preparing to create a pull request with multiple code changes and comments. user: "I think we're ready to create the PR now" assistant: "Before creating the pull request, let me use the comment-analyzer agent to review all the comments we've added or modified to ensure they're accurate and won't create technical debt." <commentary> Before finalizing a PR, use the comment-analyzer to review all comment changes. </commentary> </example>
Use this agent when a major project step has been completed and needs to be reviewed against the original plan and coding standards. Distinct from code-reviewer (which focuses on CLAUDE.md/style compliance) — plan-reviewer is plan-aware: it compares the implementation against the design doc, brainstorm output, or written plan, and flags deviations from intent. Examples: <example>Context: A plan task has just been finished. user: "I've finished implementing the user authentication system as outlined in step 3 of our plan" assistant: "Now let me use the plan-reviewer agent to verify the implementation matches the plan and coding standards" <commentary>A numbered step from the plan has been completed; use plan-reviewer to validate the work against the plan and identify deviations.</commentary></example> <example>Context: Significant feature implementation finished. user: "The API endpoints for the task management system are now complete - that covers step 2 from our architecture document" assistant: "Let me have the plan-reviewer agent examine this implementation to ensure it aligns with our architecture document and follows best practices" <commentary>An architecture-document step is done — plan-reviewer compares implementation vs. document.</commentary></example>
Use this agent when you need to review a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or updated to ensure tests adequately cover new functionality and edge cases. Examples: <example> Context: Daisy has just created a pull request with new functionality. user: "I've created the PR. Can you check if the tests are thorough?" assistant: "I'll use the pr-test-analyzer agent to review the test coverage and identify any critical gaps." <commentary> Since Daisy is asking about test thoroughness in a PR, use the Task tool to launch the pr-test-analyzer agent. </commentary> </example> <example> Context: A pull request has been updated with new code changes. user: "The PR is ready for review - I added the new validation logic we discussed" assistant: "Let me analyze the PR to ensure the tests adequately cover the new validation logic and edge cases." <commentary> The PR has new functionality that needs test coverage analysis, so use the pr-test-analyzer agent. </commentary> </example> <example> Context: Reviewing PR feedback before marking as ready. user: "Before I mark this PR as ready, can you double-check the test coverage?" assistant: "I'll use the pr-test-analyzer agent to thoroughly review the test coverage and identify any critical gaps before you mark it ready." <commentary> Daisy wants a final test coverage check before marking PR ready, use the pr-test-analyzer agent. </commentary> </example>
Use when completing tasks, implementing major features, or before merging to verify work meets requirements
Use when executing implementation plans with independent tasks in the current session
Use when you have a written implementation plan to execute in a separate session with review checkpoints
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A personal Claude Code marketplace bundling opinionated GitHub-workflow slash commands.
_ _ _ ____
| | | | |__ ___ _ __| _ \ _____ __
| | | | '_ \ / _ \ '__| | | |/ _ \ \ / /
| |_| | |_) | __/ | | |_| | __/\ V /
\___/|_.__/ \___|_| |____/ \___| \_/
Two commands. Zero ceremony. Every issue, triaged and shipped.
Two slash commands that turn issue triage and resolution into one-line operations:
| Command | What it does |
|---|---|
/solve <issue-number> | Spawns an autonomous Claude agent in a new terminal session (cmux / Ghostty / iTerm / Terminal.app / nohup) with tier-aware triage so trivial issues skip the brainstorm and large ones get the full plan-and-review pipeline. |
/issue <description> | Creates a well-investigated, deduped, label-validated GitHub issue from a one-line ask — including codebase search, full-text dedup against closed issues (regression signals), commitlint scope validation, and a triage hint that /solve reads later. |
Both are repo-agnostic — they auto-detect the current repo via gh repo view. No per-repo config required.
# 1. Add this repo as a Claude Code marketplace
/plugin marketplace add TheFJK/UberDev
# 2. Install the plugin
/plugin install uberdev@uberdev
# 3. Smoke-test
/uberdev:issue trivial typo in README install step
Optional — once verified, deconflict any pre-existing global commands so the unqualified /solve and /issue resolve to the plugin:
rm -i ~/.claude/commands/solve.md ~/.claude/commands/issue.md
Claude Code does not auto-update third-party plugins by default — third-party marketplaces ship with auto-update off. Two options:
/plugin marketplace update uberdev # refresh marketplace metadata
/plugin install uberdev@uberdev # reinstall to pull the new version
Or interactively: /plugin → Installed → select uberdev → re-install.
/plugin → Marketplaces tab → select uberdev → toggle auto-update on. Claude Code then picks up new versions whenever the version field in plugin.json is bumped.
Disabling everything: set
DISABLE_AUTOUPDATER=1in your shell environment to globally disable Claude Code's auto-updater (affects Claude Code itself + every plugin).
Each release bumps the version field in .claude-plugin/plugin.json, so auto-update users get clean version transitions; manual users see the new version listed under the marketplace entry.
| Requirement | Why |
|---|---|
gh CLI authenticated against your target repos | Used for repo detection, label/scope validation, dedup search, issue creation |
| macOS (Apple Silicon or Intel) | Terminal dispatch uses osascript for iTerm/Terminal.app; Linux/Windows degrade to detached nohup |
| Claude Code 2.x+ with plugin support | Required for /plugin marketplace add |
| One of: cmux, Ghostty, iTerm2, Terminal.app | /solve auto-detects; falls back to detached nohup if none found |
/solve — autonomous issue resolutionAuto-classifies a GitHub issue into a tier, then spawns an agent with a tier-appropriate workflow.
| Tier | Auto-detected from… | Spawned workflow |
|---|---|---|
| trivial | Labels typo, docs, chore, good-first-issue. Body <300 chars. Single file named. | Direct edit → test if touched code is tested → /uberdev:simplify → PR |
| small | Clear reproduction + error. Localized to one module. Estimated ≤50 LOC. | Lightweight TodoWrite plan (3–6 tasks) → TDD → /uberdev:simplify → PR |
| medium / large (default) | Labels epic, architectural, infrastructure. ≥3 files mentioned. Cross-package scope. Open questions. | Full /uberdev:brainstorm → /uberdev:write-plan → /uberdev:subagent-driven-dev → /uberdev:review-pr |
When in doubt, default to medium. The spawned agent is explicitly told it may escalate to
/uberdev:brainstormmid-flight if the scope proves larger than triaged — misclassification is recoverable, not catastrophic.
npx claudepluginhub thefjk/uberdev --plugin uberdevHarness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Superpowers Plus core skills library for Claude Code: planning, execution routing, TDD, debugging, and collaboration workflows
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
v9.44.1 — Patch release for Gemini environment/version detection and qwen auth gating. Run /octo:setup.
Unity Development Toolkit - Expert agents for scripting/refactoring/optimization, script templates, and Agent Skills for Unity C# development
Claude harness - A harness for solo developers (Vibecoders) to handle full-cycle contract development.