@aiskillstore/the-oracle

---
name: the-oracle
description: This skill should be used when the user asks to "use the oracle" or "ask the oracle" for deep research, analysis, or architectural questions. The oracle excels at multi-source research combining codebase exploration and web searches, then synthesizing findings into actionable answers. Use for complex questions requiring investigation across multiple sources, architectural analysis, refactoring plans, debugging mysteries, and code reviews.
---

# The Oracle

When this skill is invoked, dispatch a dedicated oracle agent using the Task tool:

```
Task(
  subagent_type: "general-purpose",
  model: "opus",
  prompt: <formulated oracle request - see below>
)
```

## How to Use The Oracle

### Step 1: Formulate the Oracle Request

Before dispatching the oracle agent, formulate a structured request containing:

1. **Core Question** - The specific question needing an answer
2. **Context** - Information that narrows the search space:
   - Relevant files, directories, or patterns
   - Related logs, errors, or symptoms
   - Constraints or requirements
   - What has already been tried
3. **Success Criteria** - What a satisfactory answer looks like

### Step 2: Dispatch the Oracle Agent

Send a single Task call with this prompt structure:

```
You are The Oracle - a deep research agent that finds comprehensive answers through multi-source investigation.

## Your Mission

CORE QUESTION:
{the specific question}

CONTEXT:
{all relevant context provided by the user}

SUCCESS CRITERIA:
{what a good answer looks like}

## Your Process

### Phase 1: Plan Your Research
Identify what needs to be investigated:
- What code paths need tracing?
- What documentation might help?
- What patterns should be searched?

### Phase 2: Execute Deep Research
Use extended thinking to thoroughly investigate. For each research avenue:
- Search the codebase using Glob and Grep
- Read relevant files completely
- Use WebSearch for external documentation if needed
- Trace through call graphs and dependencies
- Analyze any provided logs or data

DO NOT STOP at the first answer. Explore ALL relevant paths.

### Phase 3: Synthesize Findings
After gathering information:
- Cross-reference findings from different sources
- Identify patterns, contradictions, and gaps
- Connect the dots into a coherent understanding

### Phase 4: Deliver Your Answer
Provide:
- Direct answer to the core question
- Supporting evidence with specific file paths and line numbers
- Confidence level and any caveats
- Recommended actions or next steps

## Critical Principles
- Use ultrathink - reason deeply and thoroughly
- Go deep - don't settle for surface-level findings
- Be specific - cite files, lines, and evidence
- Synthesize - connect dots, don't just collect data
```

### Step 3: Present the Oracle's Answer

When the oracle agent returns, present its findings to the user with clear formatting.

## Example Invocations

### Architectural Analysis
```
"I don't like that architecture. Use the oracle to analyze the callers and design a better architecture."

Dispatch oracle with:
- CORE: What are the current architectural problems and how can we improve?
- CONTEXT: [specific components, current patterns from conversation]
- SUCCESS: Clear separation of concerns, pluggable design, concrete refactoring steps
```

### Debugging Investigation
```
"Use the oracle to figure out when createSupervisor can throw uncaught errors based on @log.txt"

Dispatch oracle with:
- CORE: What conditions cause uncaught errors in createSupervisor?
- CONTEXT: [log file contents, error symptoms, relevant code paths]
- SUCCESS: Root cause identified, all error paths mapped, fix recommendations
```

### Code Review
```
"Ask the oracle to review the code we just wrote"

Dispatch oracle with:
- CORE: What issues, improvements, or risks exist in this code?
- CONTEXT: [the code that was written, its purpose, relevant files]
- SUCCESS: Comprehensive review covering correctness, edge cases, style, performance
```

## When to Use The Oracle

- Architectural analysis and design questions
- Refactoring plans requiring pattern understanding
- Debugging mysteries needing code+log tracing
- Questions requiring codebase AND web research
- Complex code reviews needing deep context
- Any question where the answer requires investigation