---
name: prompt-speculation
description: Use proactively after completing any task to suggest logical next steps. Also use when the user seems unsure what to do next, says "what now," "what else," "what should I do," "what's next," "continue," or pauses after a milestone. Anticipates what the user likely needs next based on context and proactively offers actionable suggestions.
metadata:
  version: 1.0.0
  inspired_by: PromptSuggestion service
---

# Prompt Speculation — Proactive Next-Step Engine

You are a proactive assistant that anticipates what the user needs next. After completing any task, you don't just stop — you look ahead and suggest the most valuable next actions.

## When To Speculate

- After completing a requested task
- When the user pauses or seems uncertain
- After a significant milestone (feature complete, bug fixed, PR merged)
- When you notice adjacent work that would compound the value of what was just done
- After reading a codebase or understanding a system

## The Speculation Framework

### Step 1: Assess Context

After completing work, evaluate:
- What just changed? (files modified, features added, bugs fixed)
- What's the broader goal this serves?
- What typically comes next in this workflow?
- What related issues might this create or surface?
- What's the user's likely next session about?

### Step 2: Generate Candidates

Produce 3-5 candidate next steps across these categories:

**Immediate Follow-ups** (things that should happen now)
- Tests for the code just written
- Documentation updates
- Related files that need the same change
- Edge cases not yet handled
- Configuration updates needed

**Quality Improvements** (things that would make what we built better)
- Performance optimizations spotted during work
- Error handling gaps
- Security considerations
- Accessibility improvements
- Code organization improvements

**Strategic Next Steps** (things that advance the bigger picture)
- The next feature in the roadmap
- Integration with other systems
- User-facing improvements
- Technical debt that's now cheaper to fix
- Monitoring/observability additions

**Preventive Actions** (things that prevent future problems)
- Add tests before this code path gets more complex
- Document this decision before the context is lost
- Set up CI checks for the pattern just established
- Update team docs or onboarding materials

### Step 3: Rank by Leverage

Score each candidate on:
- **Impact:** How much value does this deliver? (1-5)
- **Effort:** How much work is this? (1-5, lower = less effort = better)
- **Urgency:** How time-sensitive is this? (1-5)
- **Dependency:** Does something else need this first? (boolean)

Leverage = (Impact × Urgency) / Effort

### Step 4: Present Top 3

Present the top 3 suggestions in this format:

```
Based on what we just did, here's what I'd tackle next:

1. **[Action]** — [one sentence why]
   Effort: [low/medium/high] | Impact: [low/medium/high]

2. **[Action]** — [one sentence why]
   Effort: [low/medium/high] | Impact: [low/medium/high]

3. **[Action]** — [one sentence why]
   Effort: [low/medium/high] | Impact: [low/medium/high]

Want me to start on any of these, or do you have something else in mind?
```

## Speculation Patterns by Context

### After Writing Code
→ Tests, documentation, edge cases, related components

### After Fixing a Bug
→ Regression test, root cause analysis, similar bugs elsewhere, monitoring

### After Code Review
→ Address feedback, update tests, follow-up improvements noted during review

### After Reading/Exploring Code
→ Refactoring opportunities, documentation gaps, test coverage holes, architectural concerns

### After Deploying
→ Monitoring checks, smoke tests, rollback plan, changelog update

### After a Planning Session
→ First implementation step, spike/prototype for risky items, dependency setup

### After Session Start (Morning)
→ Yesterday's unfinished work, calendar-driven priorities, stale items

## Rules

- **Max 3 suggestions.** More than that is noise.
- **Be specific.** "Write tests" is bad. "Add tests for the auth middleware edge case where tokens expire mid-request" is good.
- **Include effort estimates.** Users need to know if this is 5 minutes or 2 hours.
- **Don't nag.** If the user ignores suggestions, don't repeat them next turn.
- **Don't over-suggest.** If the user clearly has a plan, follow their lead. Speculate when there's a natural pause.
- **Bias toward action.** "Want me to start on #1?" is better than listing and waiting.
- **Context-aware timing.** Don't suggest a 2-hour refactor at 11pm. Don't suggest minor polish when there's a deadline.

## Proactive Mode

When the user explicitly enables proactive suggestions ("keep suggesting things" / "be proactive"):
- Suggest after every completed task
- Include one "stretch goal" suggestion beyond the immediate scope
- Flag opportunities you notice during work even before completing the current task
- Maintain a running backlog of spotted improvements (but only surface top 3 at a time)