parallel-investigation

Solid

Coordinates parallel investigation threads to simultaneously explore multiple hypotheses or root causes across different system areas. Use when debugging production incidents, slow API performance, multi-system integration failures, or complex bugs where the root cause is unclear and multiple plausible theories exist; when serial troubleshooting is too slow; or when multiple investigators can divide root-cause analysis work. Provides structured phases for problem decomposition, thread assignment, sync points with Continue/Pivot/Converge decisions, and final report synthesis.

Code & Development 1,177 stars 108 forks Updated today Apache-2.0

Install

View on GitHub

Quality Score: 99/100

Stars 20%
100
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# Parallel Investigation Coordinate parallel investigation threads to explore multiple hypotheses simultaneously. Most effective for production incidents, performance regressions, or integration failures where the root cause is unclear. ## Core Principle **When uncertain, explore multiple paths in parallel. Converge when evidence points to an answer.** Parallel investigation reduces time-to-solution by eliminating serial bottlenecks. ## Investigation Structure ### Phase 1: Problem Decomposition Break the problem into independent investigation threads: ``` Problem: API responses are slow Investigation Threads: ├── Thread A: Database performance │ └── Check slow queries, indexes, connection pool ├── Thread B: Application code │ └── Profile endpoint handlers, check for N+1 ├── Thread C: Infrastructure │ └── Check CPU, memory, network latency └── Thread D: External services └── Check third-party API response times ``` Each thread should be independent (no blocking dependencies), focused (clear scope), and time-boxed. ### Phase 2: Thread Assignment Assign threads with clear ownership: ```markdown ## Thread A: Database Performance **Investigator:** [Name/Agent A] **Duration:** 30 minutes **Scope:** - Query execution times - Index utilization - Connection pool metrics **Report Format:** Summary + evidence ``` ### Phase 3: Parallel Execution Each thread follows this pattern: 1. Gather evidence specific to thread scope 2. Document findings as you go 3. Identi...

Details

Author
rohitg00
Repository
rohitg00/skillkit
Created
4 months ago
Last Updated
today
Language
TypeScript
License
Apache-2.0

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Solid

parallel-debugging

Debug complex issues using competing hypotheses with parallel investigation, evidence collection, and root cause arbitration. Use this skill when debugging bugs with multiple potential causes, performing root cause analysis, or organizing parallel investigation workflows.

36,222 Updated today
wshobson
Code & Development Solid

investigate

Evidence-based investigation of issues, bugs, API calls, integrations, and other aspects of software development that need a deep dive to find the root cause and solutions. Use when you need to debug, troubleshoot, diagnose, or figure out why something is broken — especially when in-depth analysis of the reasons and an adversarial validation of the proposed solution are needed. Does not review code for quality or style — use code-review for auditing changes or post-code-review-to-pr for posting review feedback to GitHub. Does not assess architectural health or structural risk — use architectural-analysis for architectural concerns. Does not research open-ended options, prior art, or how something works when nothing is broken — use research for that. Does not capture feedback on Han's own skills — use han-feedback for that.

69 Updated 2 days ago
testdouble
AI & Automation Listed

parallel-research

Multi-agent parallel research methodology. 3-5 agents investigate different perspectives of a topic simultaneously for comprehensive coverage with minimal overlap. 4x speedup vs sequential research.

0 Updated 5 days ago
puretechnyc
AI & Automation Solid

phxinvestigate

Investigate bugs and errors in Elixir/Phoenix — root-cause analysis for crashes, exceptions, stack traces, test failures. Use --parallel for deep 4-track investigation.

384 Updated 4 days ago
oliver-kriska
AI & Automation Solid

investigate

Systematic root-cause debugging — find the cause before writing any fix

4,608 Updated 2 days ago
FlorianBruniaux