Tally
From Local Dev Journal to GitHub-Native Code Review Copilot
Context & Problem
Software teams don't really struggle with "not enough data." They struggle with time:
PRs that sit untouched for days
Huge "God PRs" that nobody wants to review
Junior devs drowning in context when they join a project
PMs asking "What actually happened this week?"
The Result:
- • Slower cycle times
- • Burned-out reviewers
- • No shared memory of why decisions were made
Core Question
"Can we turn the mess of commits, diffs, and ad-hoc notes into usable, team-wide understanding of code changes?"
That started as TimeTrace, a personal developer journal, and evolved into Tally, a GitHub-native code review copilot.
Origins – TimeTrace (v0)
Initial Idea
TimeTrace began as an AI-powered developer journal:
- Watch local file changes and Git commits
- Automatically generate daily summaries of work
-
Show everything on a calendar/timeline to answer:
- • "What did I actually do yesterday?"
- • "What changed before that bug appeared?"
- • "How did this feature evolve?"
Early Features
File Watcher
Tracked edits to source files
Git Watcher
Captured commits with metadata
AI Summarization
Technical summary + client/PM summary
Timeline UI
React calendar view of days, sessions, commits
Tauri Desktop App
Local-first, cross-platform
Privacy by Design
Local storage + optional local models (Ollama)
✓ What Worked
- • Individual devs loved reconstructing their week without manual notes
- • Persona-aware summaries made standups and updates easy
⚠ What Didn't
"Daily summaries are nice, but our real bottleneck is PRs: code reviews are slow, risky, and inconsistent."
TimeTrace was helping after the fact. Teams needed help inside the PR workflow.
The Pivot – From TimeTrace to Tally
Insight
From conversations with engineers, team leads, and students, the most stressful part of the workflow wasn't "What did I do this week?"
It was:
"Is this PR safe to merge?"
"How long will this review take?"
"Who should review it?"
"Why are our reviews getting slower?"
TimeTrace Already Had:
- ✓ Parsing of diffs and code changes
- ✓ Persona-based summaries
- ✓ A solid local-first architecture
The next step was obvious: Move from "logging the past" → to "shaping and de-risking PRs in real time."
Rebrand & Repositioning
What Tally Is Today
Tally is a GitHub-native code review copilot that scores PR risk, estimates review time, generates persona-aware summaries & checklists, suggests how to split large PRs, and shows teams how pickup & review times change over time.
Tally is live right now as a Mac desktop app, with the GitHub App + team analytics layer in active development.
Core Use Cases
👤 For Individual Developers
- See a timeline of work: files edited, commits, branches
- Get auto-generated summaries for yourself (technical) and PM/client (plain-language)
- Use Tally as a personal dev journal to prepare PR descriptions and standup updates faster
👥 For Reviewers & Tech Leads (Tally V2)
Open a PR and see:
- Risk score (based on size, churn, critical files, test coverage)
- Estimated review time (5 minutes, 20 minutes, 1+ hour)
- Auto-generated checklist ("Run migrations", "Check config flags", etc.)
- Persona-aware summary (Engineer view + PM view)
- Split suggestions for oversized PRs
📊 For Teams / Managers (Tally V2)
Team dashboard with:
Track how these metrics move over time as you adopt Tally, change review policies, or introduce new team members.
System Architecture
Tally's architecture grew out of TimeTrace's multi-process design and is evolving into a hybrid desktop + GitHub App system.
High-Level Architecture
1 Desktop Client (Tauri + React) – Live Now
- • Runs on macOS as a Tauri app
- • Watches local repositories (Node file watcher + Git utilities)
- • Stores data locally for privacy
- • Talks to local AI (Ollama) or remote AI APIs (OpenAI)
2 Backend Services (Node/TypeScript + Fastify)
- • Ingests events (local file/commit events + GitHub webhooks for PRs)
- • Processes & normalizes data (repos, branches, sessions, PRs, diffs)
- • Runs AI pipelines (summaries, risk scoring, time estimation, checklists)
- • Exposes APIs for desktop client and future web dashboards
3 GitHub App & Integrations (Tally V2)
- • GitHub App for PR opened/updated/merged events
- • Webhook handler receives PR diff & metadata
- • Surfaces results as status checks on PRs
- • Slack/Notion integrations (planned)
Key Components (Tech Stack)
Frontend
- • React + TypeScript
- • Calendar & timeline views
- • PR details & summaries
Desktop Container
- • Tauri (Rust)
- • System-level access
- • File & Git watchers
AI Engine
- • Node service orchestration
- • Persona-aware summarization
- • Risk scoring heuristics
- • Local (Ollama) or Cloud LLMs
Data Storage
- • Local JSON/files (current)
- • SQLite (local)
- • Postgres (team mode)
Versions & Evolution
v0 – TimeTrace Prototype
- • Local file watcher
- • Git commit ingestion
- • Single AI summarizer
- • Calendar UI for daily work logs
Outcome: Validated that automatic, persona-aware summaries were useful and technically feasible.
v0.5 – TimeTrace Advanced
- • Better timeline & UI polish
- • Dedicated "technical" vs "client" summaries
- • Improved AI prompts and context windows
Outcome: Teams wanted help specifically at the PR stage, not just day/week summaries.
v1.0 – Tally (Rebrand + Desktop App) – Live Now
- • TimeTrace → Tally rebrand
- • macOS Tauri app packaged and shipped
- • Refined onboarding for individual devs
- • Stable local workflow
v1.1 – Tally UX & Stability Improvements (In Progress)
- • UI refinements based on internal UX audit
- • Clearer navigation between days, sessions, commits
- • Better error handling and resilience
- • Foundation for GitHub App integration
v2.0 – GitHub-Native Code Review Copilot (Planned)
Installs per repo/org, listens to PR events
Size, churn, critical files, test coverage
5 min, 25 min, 60+ min predictions
Auto-generated review checklists
Break down oversized PRs
Pickup, review, merge time trends
Impact So Far
Reduced Cognitive Load
Developers don't have to remember everything they did yesterday to write a PR description or standup update—Tally reconstructs it.
Clear Narratives for Non-Engineers
Persona-aware summaries help communicate work to PMs, clients, or professors without rewriting everything by hand.
Clear Path to Team Value
Conversations with engineers and leads have consistently reinforced the core insight: speeding up and de-risking PRs is a top-of-mind problem.
- • Teams are already paying for tools that try to solve it
- • Few combine local-first privacy, AI summaries, and concrete time metrics
- • Even fewer treat PRs as narratives instead of just diffs
Tally's current live Mac app proves out the summarization + timeline + local-first engine.
Tally v2 applies that engine exactly where teams feel the most pain: code review.
Future of Tally
Roadmap
Tally v2 – GitHub App + Team Dashboard
Fully functional PR copilot with risk scoring, time estimation, checklists, split suggestions, and live metrics on pickup/review/merge time
Local-First & Privacy as a Differentiator
Stronger offline capabilities with local models (Ollama) as first-class citizens, optional encrypted sync for team analytics
Deeper Workflow Integrations
Notion/Confluence changelog generation, Jira/Linear ticket linking, IDE extensions (VSCode/JetBrains)
Learning From Teams
2–3 pilot teams using Tally, with anonymized metrics to improve risk models and discover patterns of healthy vs unhealthy PRs
Long-Term Vision
Tally's endgame is to be the shared memory and real-time health monitor of a team's code changes.
Not just "What changed?" but:
"Who needs help right now?"
"Which PR is risky?"
"Is our review culture getting better?"
"How can we make this change safer?"