googilyboogily-claude-power-tools

Interface with Blender (3D modeling, animation, rendering) through its Python API (bpy). Use whenever the user mentions Blender, .blend files, bpy, bmesh, geometry nodes, shader nodes, Cycles, EEVEE, Workbench, scene/object/material manipulation, mesh editing, armatures/rigging, keyframe animation, F-curves, drivers, NLA, importing/exporting 3D formats (GLTF/glb, FBX, OBJ, USD, STL, Alembic, Collada), batch rendering, headless render farms, CLI invocation (`blender --background --python`), authoring add-ons, custom operators/panels/menus, modal operators, PropertyGroups, Geometry Nodes trees, baking, simulation (cloth/fluid/rigid body), grease pencil, compositor nodes, or hooking Blender up to MCP / live AI control. Trigger even on vague asks like 'script Blender', 'automate Blender', 'render this from a script', or any 3D-graphics task where Blender is implied. Also trigger when the user asks to install bpy as a pip module or run Blender headless on a server.

Diagnose and fix Unraid (Lime Technology NAS OS) issues — array start/stop hangs, parity errors, disabled or emulated disks (red ball/red X), New Config and trust-parity, Docker macvlan/ipvlan call traces and custom networks, VM problems (KVM, libvirt, QEMU), GPU/USB/PCIe passthrough (IOMMU groups, VFIO, ACS override), BTRFS scrub/balance and ZFS pool degraded/corruption, mover and share allocation policies (high-water/most-free/fill-up), user shares vs disk shares, /mnt/user vs /mnt/cache vs /mnt/disk*, SMB/NFS permissions and newperms, Community Applications (CA) plugin and .plg install, /boot/config persistence, USB boot and GUID/license issues, syslog and diagnostics bundle interpretation, Fix Common Problems plugin, and version-aware release-notes lookup against docs.unraid.net. Use this whenever the user mentions Unraid, unRAID, Lime Tech NAS, or describes any symptom on an Unraid box — array won't stop, won't start, disk dropped, parity sync errors, container has no network, VM black screen, cache pool

Diagnose and fix Linux desktop issues — graphics drivers (Nvidia, AMD/Mesa, Intel), display servers (Wayland, X11, XWayland), audio (PipeWire, PulseAudio, Bluetooth), boot failures, systemd unit errors, suspend/hibernate, NetworkManager/Wi-Fi, kernel module problems, Flatpak/Snap sandbox breakage, and general desktop environment failures. Use this whenever the user reports ANY Linux desktop symptom — black screen, login loop, no audio, screen tearing, frozen cursor, GPU hangs, crashes after kernel update, broken external monitor, suspend doesn't work, app won't launch under Wayland, screen recording missing, Bluetooth pairing fails, or anything else where their Linux machine isn't behaving. Trigger even when the user just says 'my Linux is broken' or describes a vague desktop problem without naming the subsystem. Also use for proactive triage of dmesg/journalctl logs the user pastes, even if no explicit fix is requested.

Find every flaw in the overall approach and strategy of the code. Challenges whether the right problem is being solved, whether the algorithm is appropriate, whether assumptions are validated, and whether better alternatives exist. Produces severity-ranked issues with file:line references. Use when you want a dedicated approach review of code changes, files, or directories.

Find every flaw in the structural soundness, component design, and system organization of the code. Challenges whether boundaries are clean, coupling is minimized, dependencies flow correctly, and the module structure scales. Produces severity-ranked issues with file:line references. Use when you want a dedicated architecture review of code changes, files, or directories.

Find every violation of language and framework conventions, established patterns, and anti-patterns in the code. Challenges whether idioms are followed, APIs are designed correctly, and deprecated patterns are avoided. Produces severity-ranked issues with file:line references. Use when you want a dedicated best-practices review of code changes, files, or directories.

Find every flaw in failure modes, edge cases, and graceful degradation. Challenges whether all failure paths are handled, whether the system degrades gracefully or crashes spectacularly, and whether error propagation is correct. Produces severity-ranked issues with file:line references. Use when you want a dedicated error handling review of code changes, files, or directories.

Find every flaw in the long-term code health, change resilience, and future-developer experience. Challenges whether unfamiliar developers can safely understand, modify, and extend the code. Evaluates modular boundaries, debugging affordances, documentation sufficiency, and upgrade paths. Produces severity-ranked issues with file:line references. Use when you want a dedicated maintainability review of code changes, files, or directories.

Find every flaw in algorithmic efficiency, resource usage, and scalability under load. Challenges hidden O(n^2) loops, memory leaks, I/O bottlenecks, database query patterns, caching gaps, and concurrency issues. Produces severity-ranked issues with file:line references. Use when you want a dedicated performance review of code changes, files, or directories.

Find every flaw in naming, cognitive complexity, and code clarity. Challenges whether a developer can read this code and understand what it does without external context, whether intent is self-evident, and whether naming communicates purpose. Produces severity-ranked issues with file:line references. Use when you want a dedicated readability review of code changes, files, or directories.

Find every vulnerability, attack vector, and defensive coding gap in the code. Challenges injection points, authentication and authorization logic, secrets management, input validation, data exposure, and dependency risks. Produces severity-ranked issues with file:line references. Use when you want a dedicated security review of code changes, files, or directories.

Find every instance of unnecessary complexity and over-engineering in the code. Challenges whether abstractions are premature, indirection is justified, configuration is warranted, and complexity is accidental. Produces severity-ranked issues with file:line references. Use when you want a dedicated simplicity review of code changes, files, or directories.

Find every violation of SOLID principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Challenges whether the code's structure follows these principles and identifies concrete harm caused by violations. Produces severity-ranked issues with file:line references. Use when you want a dedicated SOLID principles review of code changes, files, or directories.

Find every flaw in test isolation, dependency injection, and test seam design in the code. Challenges whether code can be tested in isolation, whether dependencies are injectable, whether side effects are contained, and whether observable behavior is verifiable. Produces severity-ranked issues with file:line references. Use when you want a dedicated testability review of code changes, files, or directories.

Launch 11 specialist code critics in parallel, each attacking code from a different angle — approach, architecture, best practices, simplicity, testability, maintainability, security, performance, error handling, readability, and SOLID principles. Consolidates findings into a unified severity-ranked report with cross-cutting pattern analysis. Use when you want a comprehensive multi-dimensional code review.

Identify gray areas and capture key decisions before writing an Architecture Decision Record. Scouts the codebase, surfaces 3-5 concrete decision points that would change the outcome, and guides the user through each. Outputs a numbered decisions file that feeds into adr-gather and adr-generate.

Compile a structured context file for ADR generation by merging decisions (from adr-discuss) and research (from arch-research) with any remaining gap-fill questions. Can also run standalone with direct Q&A when no decisions file exists.

Generate an Architecture Decision Record from a gathered context file. Runs with clean context — reads the context file and produces a complete MADR 4.0.0 document. Non-interactive.

Run the full architecture documentation pipeline: ADR discuss → research → gather → generate → audit → HLD(s) discuss → research → gather → generate → audit → LLD(s) discuss → research → gather → generate → audit. Supports 1:N HLDs per ADR and 1:M LLDs per HLD. Each phase runs with clean context isolation. Persists state for cross-session resume. Prompts for context clearing between major transitions.

Standalone research phase that investigates the implications of architecture decisions. Reads a decisions file from a discuss phase, dispatches parallel code and web research focused on those decisions, and produces a structured RESEARCH.md with comparison tables, 'don't hand-roll' warnings, and confidence-tiered sources.

Audit an Architecture Decision Record for MADR 4.0.0 compliance, source integrity, completeness, and internal consistency. Walks through each issue interactively with resolution options including parallel code + web research.

Audit a High Level Design document for template compliance, source integrity, ADR alignment, architectural completeness, and context fidelity. Walks through each issue interactively with resolution options including parallel code + web research.

Audit a Low Level Design document for template compliance, source integrity, HLD alignment, implementation readiness, and context fidelity. Walks through each issue interactively with resolution options including parallel code + web research.

Use when investigating a codebase to understand existing patterns, trace execution paths, find reusable utilities, identify implementation gaps, or map dependencies. Invoke before writing design documents, during ADR/HLD/LLD exploration phases, when onboarding to unfamiliar code, or when comparing implementations against specifications.

PR-Aware Architecture Document Review — pulls GitHub PR comments, identifies grey areas across reviewer feedback as R-XX review decisions, tracks all comments (resolved + unresolved) with thread status, produces REVIEW.md state file with resume capability

Identify gray areas and capture architecture-level decisions before writing a High Level Design. Scouts the codebase and ADR constraints, surfaces 3-5 concrete decision points about component boundaries, integration patterns, and technology selections. Outputs a numbered decisions file that feeds into hld-gather and hld-generate.

Compile a structured context file for HLD generation by merging decisions (from hld-discuss), research (from arch-research), and ADR constraints with gap-fill questions. Can also run standalone with direct Q&A when no decisions file exists.

Generate a High Level Design document from a gathered context file. Runs with clean context — reads the context file and produces a complete HLD. Non-interactive.

Architecture Document Implementation — ingests an HLD or LLD, performs gap analysis, establishes goal-backward must-haves, creates a phased plan, executes with verification, and validates goals were achieved. Supports pause/resume for multi-session implementation.

Extract actionable items from an ADR, HLD, or LLD and create Jira tickets under a specified epic. Detects document type, applies section-specific extraction rules, drafts tickets for human review, creates them via Atlassian MCP, and writes a ticket manifest to docs/context/. All tickets created unassigned.

Identify gray areas and capture implementation-level decisions before writing a Low Level Design. Scouts existing code patterns and HLD constraints, surfaces 3-5 concrete decision points about interfaces, state management, error handling, and testing strategy. Outputs a numbered decisions file that feeds into lld-gather and lld-generate.

Compile a structured context file for LLD generation by merging decisions (from lld-discuss), research (from arch-research), and HLD constraints with gap-fill questions. Can also run standalone with direct Q&A when no decisions file exists.

Generate a Low Level Design document from a gathered context file. Runs with clean context — reads the context file and produces a complete LLD with method signatures, sequence diagrams, error catalogs, and implementation plan. Non-interactive.

Use when external knowledge is needed — SDK documentation, API references, best practices, GitHub issues, Stack Overflow solutions, competitor implementations, blog posts, RFCs, or technical standards — to inform design decisions, fill knowledge gaps, or validate architectural approaches.

Update, audit, or create a project's README.md to match its current state. Explores the codebase in parallel to discover structure, dependencies, recent changes, and API surface, then compares findings against the existing README to identify missing sections, outdated content, and stale references. Use this skill when the README is out of date, after major refactors or version bumps, before a release, during onboarding to a new repo, or whenever the user mentions updating, fixing, refreshing, auditing, or syncing their README. Also triggers when the user says things like 'the README is wrong', 'README needs work', 'docs are stale', 'bring it up to date', 'check the readme', 'create a readme from scratch', or wants a dry-run audit of README accuracy. This skill is specifically for README.md files — not for CHANGELOG, CONTRIBUTING, API docs, JSDoc, or documentation sites.

Audit skills, commands, and agents against the project's docs/ standards (templates.md, best-practices.md, audit-checklists.md). Auto-detects artifact type. Supports single artifact path or batch mode (--all, --type skill|command|agent).

Conduct a comprehensive architecture review of a codebase or component. Evaluates structural patterns, data flow, resilience, security, and evolution potential. Produces a prioritized written report.

Reorganize files and folders using PARA, Diataxis, and MECE methodologies. Use when asked to restructure directories, design taxonomies, standardize naming conventions, or detect structural anti-patterns.

Explore a project codebase and generate optimized, distributed CLAUDE.md files across logical sub-locations. Creates a root CLAUDE.md index/router and focused sub-CLAUDE.md files per major directory or subsystem. Intelligently merges with existing files. Use when setting up CLAUDE.md for a new project, restructuring Claude context after a major refactor, or when CLAUDE.md is bloated and needs splitting. Also use when asked to 'create CLAUDE.md', 'set up Claude context', 'distribute CLAUDE.md', 'generate CLAUDE.md hierarchy', 'split CLAUDE.md', 'optimize CLAUDE.md', or 'generate project guidance for Claude'.

Audit an existing Claude Code agent/subagent for quality, routing mesh compliance, and best-practice adherence. Checks frontmatter, domain expert criteria, routing mesh, content quality, proactive triggers, and source integrity. Interactive issue resolution with parallel code + web research forks.