Discover Work

Perform thorough research across all project surfaces to discover new tasks, gaps, technical debt, and improvement ideas that haven't been captured yet.

Overview

This skill systematically investigates six research dimensions, synthesizes findings, and presents a prioritized list of discovered work items. It goes beyond what /next-task does (which picks from existing issues) — this skill finds new work that nobody has filed yet.

Research Dimensions

Work through each dimension. Use the Agent tool to parallelize independent research. Present findings grouped by dimension, then synthesize into a final prioritized list.

1. Codebase Markers

Search the entire src/ tree for signals of incomplete or problematic code:

Patterns to search (case-insensitive):
  TODO, FIXME, HACK, WORKAROUND, TEMPORARY, DEFER, XXX, BUG, PERF,
  NotImplementedException, throw new NotSupportedException,
  "// removed", "// disabled", "// old", "// legacy"

For each hit, read surrounding context (5-10 lines) to understand whether it's:

• A genuine gap that needs a ticket
• A known deferral already tracked in .claude/state/issues.md
• A false positive (e.g., test code, intentional placeholder)

Skip false positives. Flag genuine gaps.

2. GitHub Issues & Discussions

Use gh CLI to pull:

# Open issues with details
gh issue list --state open --limit 100 --json number,title,labels,milestone,body,assignees,createdAt,updatedAt

# Closed issues (look for reopened patterns, incomplete fixes)
gh issue list --state closed --limit 30 --json number,title,labels,closedAt,body

# Discussions
gh api repos/{owner}/{repo}/discussions --jq '.[] | {number, title, category: .category.name, body, comments: .comments, created_at}'

# PRs (open and recently merged — look for follow-up items)
gh pr list --state merged --limit 20 --json number,title,body,mergedAt,labels
gh pr list --state open --limit 10 --json number,title,body,labels

Look for:

• Issues that are stale (no updates in 2+ weeks, no assignee, needs-triage label)
• Issues missing labels, milestones, or size estimates
• Closed issues whose fixes were partial (check for "deferred", "follow-up", "TODO" in close comments)
• Discussions with unresolved questions or design decisions
• Merged PRs that mention "follow-up" or "deferred" work
• Open PRs that have been sitting without review

3. Project Board

Use gh project to analyze board health:

# Get all board items with status
gh project item-list {PROJECT_NUMBER} --owner {OWNER} --format json --limit 100

Look for:

• Items stuck in "In Progress" for too long
• Items in "Todo" that have unresolved blockers
• Gaps: issues that exist but aren't on the board
• Orphaned board items (no linked issue)
• Missing columns or workflow gaps

4. Architecture & State Files

Read these files and cross-reference against the actual codebase:

• .claude/state/decisions.md — Are all decisions implemented? Any that need revisiting?
• .claude/state/conventions.md — Are conventions being followed? Any new patterns that should be documented?
• .claude/state/issues.md — Are "Open" issues still relevant? Any "Fixed" issues that regressed?
• docs/v0.3.0-plan.md — What was planned but not yet built?
• docs/sources/index.md — Does documentation match implementation?

Look for:

• Decisions that were made but never implemented
• Conventions that code violates
• Plan items that were skipped or deferred
• Documentation that's out of date
• Missing documentation for new features

5. Test Coverage Gaps

Analyze test structure against source structure:

# List all source files
find src/ -name "*.cs" -not -path "*/obj/*" -not -path "*/bin/*"

# List all test files
find tests/ -name "*.cs" -not -path "*/obj/*" -not -path "*/bin/*"

Look for:

• Source files with no corresponding test file
• Features added recently (check git log) that lack tests
• Integration test gaps (e.g., new endpoints without API tests)
• Test files that test obsolete functionality

6. Cross-Cutting Concerns

Look for systemic issues that span multiple files:

• Security: Endpoints without auth, unsanitized inputs, missing CORS, exposed secrets
• Error handling: Swallowed exceptions, missing try-catch in critical paths, inconsistent error responses
• Performance: N+1 queries, missing pagination, unbounded collections, missing caching
• Observability: Missing logging in critical paths, no structured logging, no metrics
• UX: Dead links in UI, missing loading states, error states without user feedback
• Dependencies: Outdated NuGet packages, deprecated API usage, security advisories

Synthesis & Output

After completing all research dimensions, synthesize findings into a single prioritized report.

Report Structure

Present the report in this exact format:

# Work Discovery Report

**Date**: {today}
**Scope**: Full codebase + GitHub + project board

## Executive Summary
{2-3 sentences: how many items found, most critical category, overall health}

## Critical Findings
{Items that should be addressed immediately — security, data loss, broken functionality}

## New Feature Ideas
{Gaps in functionality, user-facing improvements, things competitors have}
Each item: **Title** — Description. Suggested milestone. Estimated size.

## Technical Debt
{Code quality, missing tests, outdated patterns, deferred work}
Each item: **Title** — Description. Impact if ignored. Estimated size.

## Documentation Gaps
{Missing docs, outdated docs, undocumented features}

## Process Improvements
{Board hygiene, label gaps, workflow issues}

## Already Tracked (Validation)
{Items found during research that are already captured in existing issues — confirms coverage}

Prioritization Criteria

Rank items by:

1. Impact: How many users/features does this affect?
2. Risk: What happens if we ignore it?
3. Effort: How much work is it? (prefer quick wins)
4. Dependencies: Does this unblock other work?

De-duplication

Before presenting any finding, check it against:

• Open GitHub issues (by keyword search)
• .claude/state/issues.md open items
• Items already on the project board

If already tracked, move it to the "Already Tracked" section with a reference to the existing issue/item.

After the Report

Ask the user if they'd like to:

1. Create tickets — Use /create-tickets to batch-create issues from the findings
2. Deep-dive — Investigate a specific finding in more detail
3. Triage — Walk through findings one by one for keep/skip/modify decisions

Important Notes

• Use the Agent tool to parallelize independent research dimensions (e.g., codebase markers + GitHub issues + project board can all run in parallel)
• Read the MEMORY.md file first to understand project context and avoid re-discovering known items
• Be specific: "The FooService is missing error handling on line 42" is better than "Some services need error handling"
• Include file paths and line numbers for all code findings
• Don't suggest work that contradicts decisions in decisions.md
• Respect the project's conventions from conventions.md
• When checking GitHub, use the repo owner/name from gh repo view