Our Mission
In the age of AI-written code, development is no longer a language spoken only by developers. Thousands of lines are produced in a day; dozens of alternatives are considered, and one is chosen. But the heavier half of that decision — "why this was chosen" and "why the rest were rejected" — lives in neither the diff nor the commit message, and vanishes together with the agent's context window the moment the session ends.
AIFlare is built to turn that vanishing context into a team's memory. The moment an agent makes a commit, its intent, the alternatives it considered, and a diff summary are captured through a Skill and flow straight into a shared timeline — with no extra documentation work. The record reads as a short narrative, not a git log, so PMs, designers, and team leaders who never open the source can still follow "what the team built today, and why" on the same page as the engineers.
And that record becomes material for the future. Five AI insight reports — session summary, daily digest, weekly team digest, session compare, and prompt evaluation — pull patterns and meaning out of the record, while decisions read together and pinned by the team flow back into the next agent session as context for a better first proposal. If git has spent twenty years recording how code changed, AIFlare exists to preserve why it was built and who understands it, as the team's shared asset. And because that record lives inside the team's own git repo — GitHub, GitLab, Bitbucket, self-hosted, anywhere — the asset stays with the team even if you stop using AIFlare.
The Problem
AI coding agents have made writing code faster, but context — "why was this built this way?" — disappears even faster. Git commit messages capture what changed, but not what alternatives the AI considered or why this approach was chosen.
Reviewers spend most of their review time reverse-engineering the intent behind hundreds of AI-generated lines.
Six months later, nobody knows why an architectural decision was made.
Who It's For
Developers running side projects with AI agents who want to turn their work history into a lasting asset.
Engineers who need to quickly verify the intent and risk of AI-generated code.
Team members who need to track complex changes made by colleagues or AI.
Value Proposition
The context-capture Skill automatically writes Intent / Alternatives / Diff summaries to the aiflare/timeline/v1 branch in your own git repo right after each commit. Git itself — not an external database — is the body's permanent store.
A "dev blog"-style feed that's more readable than raw commit logs.
Public timelines, comments, and favorites let teams share decision context together.
5 report types: session summary, daily digest, session compare, weekly team digest, prompt evaluation.
Feature Highlights
AIFlare ships a set of capabilities that turn AI-assisted work into lasting context without breaking your daily dev flow. They fall into two pillars: Record & Share, and AI Insight Reports.
Automatic timeline
Every commit your AI agent makes is captured with its intent, the alternatives it considered, and a diff summary — automatically written to the project timeline. The body itself lives on the aiflare/timeline/v1 branch in your own git repo (entries/<commit_hash>.json); the AIFlare backend fetches it via your registered git remote credential and manages only metadata and derived indices — host-agnostic, no vendor lock-in. Unlike a plain commit log, the "why" stays with each change so you can reconstruct the reasoning days or months later, and tag, date, session, and full-text search let you pinpoint the exact entry in seconds across hundreds of records.
Team collaboration view
Every pushed entry from your teammates flows into a shared public timeline, so you can see in real time who worked on what and why. Consecutive commits collapse into session-level groups that reveal a single cohesive flow, and you can filter by member or mark entries with comments and favorites to focus on what the team should review together. The result is much faster onboarding into any change before a code review.
Projects dashboard
The hub you land on right after signing in: org-scoped activity stats (sessions, captures, changed files) and the latest report feed live side by side. The left sidebar lets you jump between orgs and projects, while a right-side activity panel surfaces recent changes without covering your main work. Creating and joining projects happens inline from the same view.
Daily digest
A single Markdown report that rolls up a day's commits, sessions, tag distribution, and notable decisions. One command in Claude Code or Codex generates it, stores it on the web, and optionally issues a public share link or exports it as Markdown/PDF — daily retrospectives capturing "what happened today and why" without any manual write-up.
Weekly team digest
A weekly report that aggregates contributions per member and per area of work, highlights notable design decisions, and flags focus points for next week. Unlike the personal digest, it takes a team view that surfaces time allocation and bottlenecks, producing material polished enough to drop straight into stand-ups, 1on1s, or manager updates.
Session summary
A single-page report describing what a Work Session was trying to accomplish, which alternatives were considered, and what ultimately changed. It lets you recap the full arc of a multi-commit task in minutes, and doubles as durable documentation you can hand to a reviewer or a new teammate to explain "why this decision was made here".
Session compare
Places two Work Sessions side by side and contrasts their intent, approach, and outcomes (files changed, diff size, completed tasks). Comparing sessions that solved similar problems in different ways reveals recurring patterns and opportunities to improve — letting you refine your personal habits and AI workflow based on data, not gut feel.
Prompt evaluation
Automatically scores the prompts you sent during a Claude Code or Codex session against established prompt engineering best practices. It points out ambiguous or under-specified instructions and suggests concrete rewrites that would likely produce better outcomes. For individuals and teams serious about continuously improving how they instruct AI, this compounds into a significant long-term advantage.