find-related-work

What this skill does

# Find Related Work Skill

You have the ability to search the journal for past work related to the current task.

## When to Use This Skill

Use this skill **proactively** when:

1. **Facing similar problems**
   - Current task resembles past work
   - User asks to implement something you may have done before
   - Pattern recognition suggests related history

2. **Making technical decisions**
   - Architecture choices similar to past decisions
   - Technology selection (libraries, frameworks)
   - Design patterns or approaches

3. **Troubleshooting issues**
   - Bug seems familiar
   - Similar error messages or symptoms
   - Related to previously fixed issues

4. **Building on past work**
   - Extending existing features
   - Integrating with previous implementations
   - Following established patterns

5. **User explicitly asks**
   - "Have we done something like this before?"
   - "When did we implement X?"
   - "How did we solve Y last time?"
   - "Find anything about Z"

## How to Find Related Work

**Method 1: Keyword search**
```
journal_search(
  query="authentication",  # Technology, concept, or feature
  limit=10
)
```

**Method 2: Time-based search**
```
journal_time_query(
  time_expression="last month",
  query="caching"  # Optional: narrow down results
)
```

**Method 3: Project-specific search**
```
journal_search(
  query="database migration",
  project="my-api"  # Focus on specific project
)
```

**Method 4: Project history**
```
journal_list_recent(
  project="mobile-app",
  limit=20  # Get comprehensive project context
)
```

## Search Strategies

**Broad to narrow:**
1. Start with general terms ("auth", "cache")
2. Narrow if too many results ("OAuth2", "Redis cache")
3. Add project filter if needed

**Technology-focused:**
- Framework names: "React", "FastAPI", "PostgreSQL"
- Library names: "JWT", "Redis", "SQLAlchemy"
- Tool names: "Docker", "GitHub Actions", "pytest"

**Concept-focused:**
- Features: "authentication", "notifications", "file upload"
- Patterns: "caching", "rate limiting", "error handling"
- Operations: "deployment", "migration", "refactoring"

**Time-focused:**
- Recent: "last week", "last month"
- Historical: "january", "last year"
- Specific: "2024-03-15"

## Examples

**Example 1: Similar feature request**
```
User: "Add rate limiting to the API"
[Proactively search before starting]
→ journal_search(query="rate limiting")
→ Found previous rate limiting implementation in mobile-api
→ "I found we implemented rate limiting before in mobile-api using Redis.
   Want to use a similar approach? Here's what we did: [summary]"
```

**Example 2: Architectural decision**
```
User: "Should we use PostgreSQL or MongoDB for this?"
→ journal_search(query="PostgreSQL MongoDB database choice")
→ "We chose PostgreSQL over MongoDB for api-service last month because [reasons].
   Similar requirements here?"
```

**Example 3: Debugging with history**
```
User: "Getting timeout errors on the cache"
→ journal_search(query="cache timeout error")
→ "We fixed a similar cache timeout issue in March by [solution].
   Let me check if it's the same problem..."
```

**Example 4: Pattern reuse**
```
User: "Implement file upload for users"
→ journal_search(query="file upload")
→ "Found your file upload implementation for profiles from [date].
   You used [approach] with [storage]. Use the same pattern?"
```

**Example 5: Technology recall**
```
User: "What library did we use for JWT tokens?"
→ journal_search(query="JWT library")
→ "You used PyJWT for token handling in my-api.
   Here's how it was set up: [summary]"
```

## Presenting Related Work

**Format:**
```
**Related Past Work**

Found [N] related entries:

**Most relevant:**
[Entry title] ([date]) - [project]
[Brief summary of what was done]

**Also relevant:**
- [Entry 2]: [Quick summary]
- [Entry 3]: [Quick summary]

**Suggestions:**
[How this past work applies to current task]
```

## Best Practices

1. **Search proactively**: Don't wait for user to ask
2. **Be selective**: Show most relevant, not all results
3. **Provide context**: Explain how past work relates
4. **Suggest application**: How to use this information
5. **Time-aware**: Note if information might be outdated

## What to Look For

Search for:
- **Solutions**: How problems were solved
- **Decisions**: Why choices were made
- **Patterns**: Established approaches
- **Gotchas**: Issues encountered and avoided
- **Dependencies**: Libraries and tools used

## Integration with Other Skills

Combine with:
- **context-recovery**: When related work provides session context
- **journal-capture**: After applying past solutions to new problems

## When NOT to Search

Don't search for:
- Completely novel features with no precedent
- Trivial tasks unlikely to have been journaled
- Very recent work (use context-recovery instead)
- Information better found in documentation

## Advanced Techniques

**Combine multiple searches:**
```
1. journal_search(query="authentication")  # Broad search
2. journal_search(query="OAuth2", project="my-api")  # Narrow down
```

**Use project stats for overview:**
```
journal_stats()  # See which projects have relevant history
→ journal_list_recent(project="most-relevant-project")
```

**Time-based filtering:**
```
journal_time_query(
  time_expression="last 6 months",
  query="deployment"
)  # Recent relevant work only
```