claude-code-plugin-marketplace

Conducts iterative deep research on any topic using web search, progressive exploration, and structured synthesis. Use when asked for comprehensive research, deep investigation, thorough analysis, or multi-source exploration of any topic. Triggers: research, investigate, deep dive, comprehensive analysis, explore thoroughly, find everything about.

For cross-cutting concerns: add behavior without modifying functions, caching, timing, logging, validation wrappers.

For performance work: measure before changing, profile to find bottlenecks, compare before and after.

For symbolic computation: ASTs, mathematical expressions, code that manipulates code structure, expression transformations.

For ordered processing: A* search, Dijkstra, event simulation, task scheduling. Efficient min/max extraction with heap-based queue.

For dynamic programming: overlapping subproblems, recursive solutions with repeated computations, memoization to avoid redundant work.

For persistent state: closures capture outer variables, alternative to classes for simple state, factory functions that remember context.

For flexible parsing: try multiple type conversions in order, graceful fallback from specific to general types.

For iteration with errors: catch exceptions during exploration, skip invalid cases, continue to next attempt.

For hot loop optimization: repeated formula evaluation, regex patterns, expression compilation. Transform string to callable once, call many times.

For complex behavior: build from tiny functions, chain transformations, make code read like a pipeline of operations.

For probability and counting: permutations, combinations, sample spaces, Monte Carlo simulation, brute-force enumeration, card/dice problems.

For new modules: define type aliases as vocabulary, make code self-documenting, create domain-specific language feel.

For heterogeneous data: pattern matching on type/structure, interpreter eval loops, handling different expression types.

For 2D debugging: visualize grid/board state, show puzzle progress, make algorithm behavior visible.

For cross-version support: try/except imports, optional dependencies, graceful degradation across Python versions.

For computational geometry: convex hull, point enclosure, polygon operations. Uses monotone chain algorithm with stack-based turn detection.

For pathfinding and search: shortest path, maze solving, game AI, route planning, graph traversal, BFS/DFS, Dijkstra, A* problems.

For result reporting: tabular output, aligned columns, statistics summaries, human-readable reports.

For graph exploration: frontier collection with configurable pop order, BFS/DFS/random via strategy change.

For tree/maze generation: spanning trees, random mazes, graph coverage. Uses frontier-based exploration with configurable traversal order.

For boundary conditions: empty collections, zero values, recursive base cases, null checks, prevent crashes at edges.

For fast comparison: ensure only one instance of each symbol, use 'is' instead of '==', symbol tables for interpreters.

For combinatorial iteration: permutations, combinations, cartesian products, without storing all results in memory.

For two-sided matching: hospital-resident, stable marriage, college admissions. Gale-Shapley algorithm for stable matching with preferences.

For NP-hard optimization: TSP, scheduling, assignment problems. Uses greedy construction + local improvement (2-opt, hill climbing).

For domain-specific languages: operator overloading, make Python look like math/domain notation, expression builders.

For text processing: extract numbers, words, structured data from messy text using regex patterns, parsing utilities.

For generic algorithms: strategy pattern, callbacks, configurable behavior. Pass functions as parameters to customize algorithm behavior.

For static relationships: graph structure, grid neighbors, constraint peers. Calculate once at module load, reference throughout program.

For constraint problems: eliminate impossibilities before guessing, reduce search space through inference, fail fast on contradictions.

For long functions: break into smaller pieces, extract helper functions, reduce nesting, improve testability and readability.

For graceful failure: return None or False instead of exceptions, let caller decide how to handle failure.

For comparison: display before/after, multiple solutions, diffs side by side for visual comparison.

For constraint satisfaction: Sudoku, scheduling, N-queens, logic puzzles, SAT-like problems, assignment problems. Uses propagate-then-search pattern.

For 2D grid problems: mazes, board games, tile maps, pixel grids, coordinate systems, cellular automata, flood fill. Uses dict-based Grid class pattern.

For search with undo: explicit decision stack, backtracking when paths fail, depth-first exploration with state restoration.

For data structure validation: test lengths, relationships, constraints that must hold, verify setup is correct.

For example-driven development: test cases as specifications, input/output pairs, documentation through examples.

For performance reporting: timing wrappers, throughput calculations, profiling summaries.