Use this simple prompt to generate your engineering team's lookback report for 2025

Year-end rolls around, someone says “we should really write a 2025 lookback for the team”, and suddenly you’re staring at a blank Google Doc thinking:

What did we even ship in March?
Who carried that gnarly migration in Q2?
How do I do this without spending my entire weekend in Jira, GitHub, and Slack?

If your code lives in git and you use pull requests, you already have the raw material for a great lookback report. You just need a way to turn that history into a narrative.

That’s what this prompt is for.

The idea: Let your repo tell the story

Instead of manually building a timeline from scattered tools, you give an AI assistant one job:

“Read the git log and merged PRs from 2025, group them into themes and projects, and generate an HTML report that tells the story of what we did and who did it.”

That’s literally what this prompt does.

Here’s the exact version:

Use git log history and the merged PRs in this repo to generate a report in an HTML file that highlights all the major contributions made to this repository over 2025. Create themes, or projects as groupings and mention the people that worked on those themes and projects. Fetch the detailed information for each PR that was merged in 2025 in order to generate a full picture.

Drop this into your AI coding assistant (Cursor, VS Code + ChatGPT, Claude Code, etc.) while it has access to your repo, and you’ll get a surprisingly solid first draft of a year-in-review report.

Let’s break down how to actually use it.

Step 1: Point your AI at the right repo

You want the assistant to see your repository and be able to inspect:

git log
Merged PRs for 2025
Any relevant files (e.g., CHANGELOG, docs/, migrations/, etc.)

How you do that depends on your tool:

In an AI-powered IDE (Cursor / VS Code + AI extension):
- Open the repo for your team’s primary service or product.
- Make sure the AI extension has repository access enabled.
- Open the command/chat panel and paste the prompt.
In a browser-based AI tool with GitHub integration:
- Connect GitHub.
- Point the assistant at the repo.
- Paste the prompt and explicitly mention the repo name if needed.
Manually (if you don’t have repo-aware tooling):
- Run git log for 2025 and export:
```
git log --since="2025-01-01" --until="2025-12-31" \
  --pretty=format:"%h %ad %an %s" --date=short > git-log-2025.txt
```
- Export your merged PRs for 2025 via:
  - GitHub search (is:pr is:merged merged:2025-01-01..2025-12-31)
  - Or API / CSV export.
- Paste those chunks into the AI in batches and keep the same prompt, adding:
  
  “Here is part of the log/PR list; I’ll send multiple chunks. Wait until I say ‘DONE’ before generating the HTML report.”

The more context the assistant has about your PRs, the better the story it can tell.

Step 2: Use the prompt as your “report generator”

Here’s that prompt again, plus a slightly expanded variant I recommend:

You have access to this repository's git history and merged pull requests.

Use git log history and the merged PRs in this repo to generate a report in an HTML file that highlights all the major contributions made to this repository over 2025.

Requirements:
- Only include work that shipped or merged in 2025.
- Group contributions into themes or projects (e.g. "Authentication Revamp", "Performance & Reliability", "Developer Experience Improvements").
- For each theme, list:
  - A short narrative summary (1–3 paragraphs)
  - The key PRs with titles, links, authors, and approximate dates
  - The people who contributed to that theme (engineers, reviewers, etc.)
- Call out any major migrations, incidents, architectural changes, or launches.
- Close with a "2025 in Numbers" section (PR count, contributors, notable metrics if visible).
- Output the final result as a complete HTML document suitable for sharing internally (use semantic headings, lists, and simple styling).

Fetch detailed information for each PR that was merged in 2025 in order to generate a full picture.

When you run this, your assistant will typically:

Enumerate PRs merged in 2025.
Cluster them by:
- Labels (e.g., feature, refactor, infra),
- File paths touched (e.g., auth/, billing/),
- Similarity in titles/commits.
Infer themes like:
- “Cart V2 Launch”
- “GA4 Analytics & Attribution”
- “Cross-Regional Booking Support”
Generate an HTML report that looks something like:

<h1>2025 Engineering Lookback – Branded Web Tools Team</h1>

<section>
  <h2>Authentication & Identity Modernization</h2>
  <p>In Q1 and Q2 we migrated our consumer authentication flow to a popup-based Shared UI...</p>
  <ul>
    <li>
      <strong>#342 – Implement popup-based auth widget</strong><br/>
      Author: alice – Merged: 2025-02-14
    </li>
    <!-- ... -->
  </ul>
  <p><strong>Key contributors:</strong> Alice, Bob, Carol</p>
</section>

<!-- More sections... -->

<section>
  <h2>2025 in Numbers</h2>
  <ul>
    <li>245 PRs merged</li>
    <li>11 unique contributors</li>
    <li>3 major product launches</li>
  </ul>
</section>

You now have a shareable artifact you can:

Drop into your internal wiki / Notion / Confluence
Attach to your performance packet
Use as the backbone of your team’s “What we did in 2025” presentation

Step 3: Tune the tone for your audience

By default, AI reports can sound a bit like a release notes robot. Add a follow-up prompt to tune the voice:

For leadership / exec reviews:

Rewrite this HTML report for a VP-level audience:
- Focus on outcomes, customer impact, and reduced risk.
- Reduce low-level implementation detail.
- Keep the structure, but make it 30% shorter.

For the engineering team:

Adjust the tone of this HTML report:
- Audience is the engineering team.
- Celebrate wins, call out tricky projects, and highlight collaboration.
- Keep technical details and concrete examples.

For cross-functional partners (product, design, marketing):

Rewrite this HTML report for a cross-functional audience:
- Explain technical changes in plain language.
- Tie themes back to user value and business impact.
- Avoid acronyms or explain them the first time they appear.

You don’t need to regenerate the report – you just ask the assistant to transform the HTML you already have.

Step 4: Make it a repeatable ritual

The best time to use this prompt is every year – but you can get even more value if you treat it as a recurring ritual:

Quarterly lookbacks
- Adjust the date range in your git log / PR filters.
- Update the prompt: “over Q1 2025” instead of “over 2025”.
- Use the quarterly reports as inputs for the year-end piece.

Team-level vs. org-level

Run the prompt per repo / service (e.g., cart-service, auth-service, analytics-service).

Then feed those HTML reports into a second AI pass:

Here are three HTML lookback reports for different services.
Create a single consolidated 2025 engineering lookback for the entire org.
Group themes across services, remove duplication, and keep it under 4 pages.

Performance review support

For individual engineers:

Using this HTML report and the underlying PR data, generate a bullet list of this engineer's notable contributions in 2025, grouped by theme.
Focus on impact, technical complexity, and collaboration.

Now your lookback isn’t just a “nice to have” document; it’s feeding into career narratives, promo packets, and planning.

A few practical tips to get better reports

You’ll get much higher-quality output if you invest in a bit of hygiene and structure throughout the year:

Use meaningful PR titles
- “Fix bug” → bad.
- “Fix null ref in cart checkout for guest users” → good.
- AI leans heavily on titles to infer themes.
Label or tag PRs consistently
- feature, bugfix, performance, infra, security, experiment.
- The assistant can cluster by labels and create clear sections like Performance & Reliability or Security Hardening.
Include context in descriptions
- Why the change matters.
- How it impacts users or internal devs.
- Any notable risk reduced or debt paid down.
Standardize author names
- Make sure Git authors map cleanly to team members so the assistant can correctly list contributors.
- If you have weird emails / bots, you can tell the assistant:
```
Treat 'mb-bot' as a bot; ignore it in contributor lists.
Map 'george@example.com' to 'George Gonzalez'.
```
Split huge repos
- If your monorepo is massive, run the prompt per directory / domain:
  - /web/appointments
  - /web/cart
  - /infra
- Then merge the reports with a second pass.

Security & privacy considerations

A quick but important note: your repo is your company’s IP.

Before you plug your production codebase into any AI:

Make sure your org’s policies allow it.
Use tools that:
- Support enterprise / SOC2 / data residency compliance if required.
- Offer “do not train on my data” options.
Avoid pasting secrets, logs with user data, or anything sensitive directly into cloud models.

If you’re in a strict environment, consider:

Running a self-hosted or on-prem model that can read your repo directly.
Exporting only metadata (PR titles, authors, labels, dates) instead of full diffs.

The prompt itself is safe; your data handling process is where you need to be thoughtful.

Final thoughts

A good engineering lookback report does a few things:

Reminds the team how much they actually shipped.
Surfaces the invisible work ( migrations, infra, refactors, reliability ).
Gives credit to the people who quietly carried big projects.
Helps leadership see concrete impact instead of just burn charts.

You already have the raw data in your git history and PRs. This prompt is just a thin layer that turns that history into a narrative.

Copy it, adapt it to your stack and tools, and make “writing the 2025 lookback” a 1–2 hour exercise instead of a multi-day archaeology dig.

If you end up generating a report for your team using this, I’d love to hear how it went and what you changed in the prompt to fit your world.