Investigate software errors by tracing code, reviewing recent changes, and reproducing symptoms. Test a specific cause before making a minimal fix, then verify the result with regression tests and a structured debug report.
Use when asked to debug, fix a bug, investigate an error, or do root cause analysis, and when users report errors, stack traces, unexpected behavior, or say something stopped working.
gstack-openclaw-investigate investigates the root cause of errors or unexpected behavior, then works through a fix and verification in order. It examines error messages, reproduction steps, code flow, and recent changes to form a specific, testable hypothesis. Temporary logging or similar evidence is used to check that hypothesis before making the smallest change that removes the cause.
It creates a regression test that fails before the fix and passes afterward. It then checks the result using the full test suite and the original reproduction steps. A dated report saved in memory/ records the symptoms, root cause, changes, and verification evidence.
Use it when a previously working feature suddenly breaks or a problem keeps returning despite repeated fixes. It also helps preserve the investigation and its findings for reference in later work.
Verification relies on code, reproduction steps, and tests. After three failed hypotheses, the skill discusses the investigation approach with you. It removes confidential information before external searches and explains the scope before a fix touches more than five files.
This overview was written by AI (OpenAI Codex) from the public SKILL.md. Check the original below for the exact behavior.
AI rated this skill on four points using only the contents of its SKILL.md. Stars and popularity are not taken into account.
The total counts each point as A = 25, B = 15, C = 5. Rated by AI (OpenAI Codex) as of Oct 20, 2026. Treat it as a guide and read the original before installing.
Review the instructions the agent will receive before you install.
NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
Fixing symptoms creates whack-a-mole debugging. Every fix that doesn't address root cause makes the next bug harder to find. Find the root cause, then fix it.
Gather context before forming any hypothesis.
Collect symptoms: Read the error messages, stack traces, and reproduction steps. If the user hasn't provided enough context, ask ONE question at a time. Don't ask five questions at once.
Read the code: Trace the code path from the symptom back to potential causes. Search for all references, read the logic around the failure point.
Check recent changes:
git log --oneline -20 -- <affected-files>
Was this working before? What changed? A regression means the root cause is in the diff.
Reproduce: Can you trigger the bug deterministically? If not, gather more evidence before proceeding.
Check memory for prior debugging sessions on the same area. Recurring bugs in the same files are an architectural smell.
Output: "Root cause hypothesis: ..." ... a specific, testable claim about what is wrong and why.
Check if this bug matches a known pattern:
Race condition ... Intermittent, timing-dependent. Look at concurrent access to shared state.
Nil/null propagation ... NoMethodError, TypeError. Missing guards on optional values.
State corruption ... Inconsistent data, partial updates. Check transactions, callbacks, hooks.
Integration failure ... Timeout, unexpected response. External API calls, service boundaries.
Configuration drift ... Works locally, fails in staging/prod. Env vars, feature flags, DB state.
Stale cache ... Shows old data, fixes on cache clear. Redis, CDN, browser cache.
Also check:
External search: If the bug doesn't match a known pattern, search for the error type online. Sanitize first: strip hostnames, IPs, file paths, SQL, customer data. Search the error category, not the raw message.
Before writing ANY fix, verify your hypothesis.
Confirm the hypothesis: Add a temporary log statement, assertion, or debug output at the suspected root cause. Run the reproduction. Does the evidence match?
If the hypothesis is wrong: Search for the error (sanitize sensitive data first). Return to Phase 1. Gather more evidence. Do not guess.
3-strike rule: If 3 hypotheses fail, STOP. Tell the user:
"3 hypotheses tested, none match. This may be an architectural issue rather than a simple bug."
Options:
Red flags ... if you see any of these, slow down:
Once root cause is confirmed:
Fix the root cause, not the symptom. The smallest change that eliminates the actual problem.
Minimal diff: Fewest files touched, fewest lines changed. Resist the urge to refactor adjacent code.
Write a regression test that:
Run the full test suite. No regressions allowed.
If the fix touches >5 files: Flag the blast radius to the user before proceeding. That's large for a bug fix.
Fresh verification: Reproduce the original bug scenario and confirm it's fixed. This is not optional.
Run the test suite.
Output a structured debug report:
DEBUG REPORT
Save the report to memory/ with today's date so future sessions can reference it.
No reviews yet. Tell others what you thought.
No login needed. Share how it worked for you, ask a question, or note where it did not run.
No comments yet. Be the first to write one.
Run sequential reviews of a plan from business, design, engineering, and developer experience perspectives. Apply six principles to intermediate decisions, then bring close choices, scope questions, and reviewer disagreements to a final approval step.
Measure web page loading times, rendering milestones, and resource sizes in a real browser. Save baseline measurements, compare results before and after code changes, and inspect historical trends to spot performance regressions.
Compare Claude, GPT, and Gemini on the same skill or prompt. Get a table of response times, token usage, and costs, with optional AI scoring to help choose a model for the task.
Open web pages, follow navigation, and check form flows in a browser. Capture screenshots at different screen sizes, compare pages before and after actions, and collect console errors, the technical messages that can reveal page problems.
Monitor a live app after deployment for console errors, slower performance, and page failures. Periodic screenshots and comparisons with pre-deployment baselines help identify anomalies and check whether the release is behaving as expected.
Check shell commands before they run and warn about destructive actions such as file deletion, database removal, and Git history changes. Users can approve ordinary warnings, while certain catastrophic command patterns are denied.