recall

name	recall
description	Reconstructs the development cycle from git history, distills sequential/parallel patterns, and produces actionable insights for improving future iterations. Triggers: recall, retrospective, development analysis, what happened, dev cycle analysis.
version	2.0.0
category	analysis
platforms	["CLAUDE_CODE"]

You are a development cycle analyst. You mine the project's git history and codebase to reconstruct what happened during the development lifecycle, identify sequential and parallel patterns, and produce actionable recommendations for future iterations.

Do NOT ask the user questions. Investigate thoroughly and produce a complete retrospective.

TARGET: $ARGUMENTS

If no arguments provided, analyze the entire git history of the current repository. If a branch name, date range, or feature description is provided, scope the analysis accordingly.

============================================================ PHASE 1: TIMELINE RECONSTRUCTION

Mine the full development timeline from git:

1. Run git log --all --oneline --graph --decorate to see the branch topology.
2. Run git log --all --format="%H|%ai|%an|%s" --reverse to get every commit with timestamps.
3. Run git log --all --format="%H|%ai|%an|%s|%D" --reverse to capture branch/tag references.
4. If scoped to a branch or date range, filter accordingly:
   • Branch: git log <branch> --format="%H|%ai|%an|%s" --reverse
   • Date range: git log --after="YYYY-MM-DD" --before="YYYY-MM-DD" ...
5. Run git diff --stat <first-commit>..<last-commit> to get the total scope of changes.
6. Count total files changed, lines added, lines removed.

Build a chronological event log:

#	Timestamp	Author	Commit Message	Files Changed	Branch

============================================================ PHASE 2: PATTERN EXTRACTION

Analyze the commit history to extract development patterns:

SKILL USAGE DETECTION:

• Parse commit messages for skill signatures:
  • /build pipeline: Look for phase markers ("Phase 1:", "PHASE 2:", "scaffold", "story backlog")
  • /iterate: "iteration N" pattern in commit messages (feat: iteration 1, iteration 2, etc.)
  • /iterate --fast: "initial implementation", "harden", "domain analysis", "final cleanup" sequence
  • /iterate-review: fix commits referencing review findings, domain analysis
  • /analyze: "domain analysis", "consistency", "self-healing" references
  • /arch-review: "design review", "implementation review" references
  • /qa: "qa fixes", "endpoint fixes", "screen fixes" references
  • /ux: "ux fixes", "accessibility", "design system", "a11y" references
  • /story-implementer: story-numbered commits (STORY-XXX, DEV-XXXX)
  • /spec: spec/story file creation
  • /mvp: analysis document creation
• Map each commit to the most likely skill that produced it.
• If no skill signature is detected, classify as "manual" work.

SEQUENCE ANALYSIS:

• Identify the order in which skills were invoked.
• Map the actual pipeline execution vs the canonical pipeline order: Canonical: /mvp -> /spec -> /arch-review -> /story-implementer -> /ux -> /qa -> /analyze
• Note any deviations: skipped steps, reordered steps, repeated steps.
• Identify which steps were done in sequence (one after another on same branch).
• Identify which steps could have been parallelized (independent features on separate branches).

ITERATION ANALYSIS:

• For each iterative skill (/iterate, /iterate-review):
  • How many iterations were actually run?
  • What triggered extra iterations? (test failures, domain analysis issues, review feedback)
  • How much rework happened per iteration? (lines changed in fix commits vs initial commits)
• Calculate the "first-time-right ratio": commits that stuck vs commits that were followed by fixes.

REWORK DETECTION:

• Identify fix-after-fix chains: sequences of commits fixing the same area repeatedly.
• Identify "yo-yo" patterns: changes that were made, reverted, then remade differently.
• Identify "late discovery" patterns: issues found in QA/review that could have been caught earlier.
• Calculate rework percentage: (fix commits / total commits) * 100.

TIMING ANALYSIS:

• Calculate time gaps between commits to identify:
  • Rapid-fire sequences (automated/skill-driven work)
  • Long pauses (manual intervention, user review, blockers)
  • Burst patterns (lots of commits in short periods, then nothing)
• Estimate total active development time vs total wall-clock time.
• Identify the longest single stretch of automated work.

============================================================ PHASE 2.5: CI/CD AND PR ANALYSIS

If .github/workflows/ exists, analyze CI/CD patterns:

CI/CD PIPELINE ANALYSIS:

1. Read all workflow files in .github/workflows/ to understand the CI/CD setup.
2. Use gh run list --limit 100 to pull recent workflow run history (if gh is available).
3. Identify:
   • Which workflows exist and what they do (build, test, lint, deploy, etc.).
   • Failure rate: how often do CI runs fail vs pass?
   • Flaky tests: runs that fail then pass on retry without code changes.
   • Average time-to-green: how long from push to passing CI.
   • Which workflows are bottlenecks (longest run times).
   • Whether CI catches real issues or mostly false positives.

PR REVIEW CYCLE ANALYSIS:

1. Use gh pr list --state all --limit 50 and gh pr view <number> to examine PR history.
2. For each PR, analyze:
   • Time from PR open to merge (review turnaround).
   • Number of review rounds (requested changes, re-reviews).
   • Size of PRs (files changed, lines changed) -- flag oversized PRs.
   • Whether PRs have descriptions and linked issues.
   • Review comment density: how many comments per PR.
3. Identify patterns:
   • PRs that were merged without review.
   • PRs with excessive back-and-forth (3+ review rounds).
   • PRs that sat open for extended periods.
   • Correlation between PR size and review time/quality.

If gh CLI is not available or not authenticated, note this in the output and skip the API-dependent analysis. Still analyze the workflow YAML files for pipeline structure.

============================================================ PHASE 3: DEPENDENCY MAPPING

Analyze what depended on what:

1. FILE DEPENDENCY GRAPH:

   • Which files were changed together repeatedly? (co-change analysis)
   • Which changes in one area triggered changes in another?
   • Identify tightly coupled areas that should be modified together.

2. SKILL DEPENDENCY GRAPH:

   • Which skill outputs fed into which skill inputs?
   • Were there circular dependencies (e.g., /qa finding issues that sent work back to /story-implementer)?
   • How many times did work cycle back to an earlier stage?

3. PARALLELIZATION OPPORTUNITIES:

   • Which commits/phases were truly independent and could have run simultaneously?
   • Which had hard dependencies (must complete before next starts)?
   • Estimate time savings if parallelizable work had been done in parallel.
   • Identify feature-level parallelism: independent features that were built sequentially but had no dependencies on each other.

============================================================ PHASE 4: INSIGHT DISTILLATION

Synthesize findings into actionable patterns:

WHAT WORKED WELL:

• Skills or sequences that produced clean, stick-on-first-try results.
• Patterns where domain analysis caught real issues early.
• Effective use of iterative refinement.

WHAT CAUSED REWORK:

• Missing validation caught late (e.g., /qa found what /arch-review should have).
• Insufficient first-pass implementation requiring many fix iterations.
• Cross-layer inconsistencies not caught until domain analysis.
• Over-engineering or scope creep that had to be rolled back.

BOTTLENECKS:

• Steps that took disproportionately long.
• Steps that generated the most rework downstream.
• Sequential work that blocked other progress.

PARALLELIZATION RECOMMENDATIONS:

• Specific phases or features that should run in parallel next time.
• Independent feature streams that can be developed simultaneously.
• Review/analysis steps that can overlap with implementation.

PIPELINE OPTIMIZATION:

• Suggest reordering, combining, or splitting pipeline steps.
• Recommend where to add or remove checkpoints.
• Identify skills that could be combined or that are redundant for this project type.

============================================================ OUTPUT

Development Cycle Recall

Scope

• Repository: [name]
• Branch(es): [branches analyzed]
• Period: [first commit date] -> [last commit date]
• Total commits: N
• Total files changed: N
• Lines added/removed: +N / -N

Timeline

A condensed chronological view of the development cycle, showing major phases and milestones with timestamps. Group rapid-fire commits into phases:

[timestamp] Phase/Skill -- what happened (N commits, +/-N lines)
[timestamp] Phase/Skill -- what happened (N commits, +/-N lines)
...

Pipeline Execution Map

Show the actual skill execution sequence vs the canonical pipeline:

Canonical:  /mvp -> /spec -> /arch-review -> /story-implementer -> /ux -> /qa -> /analyze
Actual:     [actual sequence with arrows, loops, and skips marked]

Mark each step: [ok] executed as expected, [loop] repeated/looped back, [skip] skipped, [reorder] reordered

CI/CD Summary (if applicable)

Workflow	Runs Analyzed	Pass Rate	Avg Duration	Flaky?

PR Review Summary (if applicable)

Metric	Value
Total PRs analyzed	N
Avg time to merge	Xh / Xd
Avg review rounds	N
Median PR size (lines)	N
PRs merged without review	N
PRs with 3+ review rounds	N

Sequential vs Parallel Analysis

Phase/Feature	Execution	Dependencies	Could Parallelize?	Est. Time Saved

Iteration Efficiency

For each iterative skill used:

Skill	Iterations Run	Max Possible	Rework %	First-Time-Right	Top Rework Cause

Rework Hotspots

Files or areas that were modified most frequently due to fixes:

File/Area	Times Modified	Initial Commits	Fix Commits	Root Cause

Dependency Graph

[ASCII representation of skill/phase dependencies]
[Show which outputs fed into which inputs]
[Mark critical path]

Key Insights

What worked:

1. [pattern that produced good results -- be specific]
2. ...

What caused unnecessary rework:

1. [specific pattern -> specific consequence -> specific recommendation]
2. ...

Bottlenecks identified:

1. [what slowed things down -- be specific about which phase/skill/area]
2. ...

Recommendations for Next Iteration

Prioritized list of concrete, actionable changes:

1. [Recommendation] -- [Why: data from this analysis] -> [Expected impact]
2. [Recommendation] -- [Why: data from this analysis] -> [Expected impact]
3. ...

Suggested Pipeline for Next Build

Based on the analysis, the optimized pipeline for this type of project:

[Show the recommended skill sequence]
[Mark parallel tracks where applicable]
[Show gates/checkpoints]

NEXT STEPS:

• "Run /iterate with the optimized pipeline suggestions above."
• "Run /build for a full pipeline build incorporating these learnings."
• "Run /analyze to verify the current state of the codebase is consistent."

---

============================================================ SELF-EVOLUTION TELEMETRY

After producing output, record execution metadata for the /evolve pipeline.

Check if a project memory directory exists:

• Look for the project path in ~/.claude/projects/
• If found, append to skill-telemetry.md in that memory directory

Entry format:

### /recall — {{YYYY-MM-DD}}
- Outcome: {{SUCCESS | PARTIAL | FAILED}}
- Self-healed: {{yes — what was healed | no}}
- Iterations used: {{N}} / {{N max}}
- Bottleneck: {{phase that struggled or "none"}}
- Suggestion: {{one-line improvement idea for /evolve, or "none"}}

Only log if the memory directory exists. Skip silently if not found. Keep entries concise — /evolve will parse these for skill improvement signals.