The retrospective is the meeting nobody schedules. After the launch ships or the project closes, the team is exhausted and the next thing is already on fire. By the time you remember the post-mortem two weeks later, the lessons feel less sharp, the timeline is fuzzy, and the people who lived the project closest have already moved on. Six months later, when you're about to repeat the exact mistake on a new project, the lesson exists only in someone's stomach.
A working setup for lessons learned isn't a heavier post-mortem template. It's a vault that holds the raw material — decision logs, meeting recaps, slack threads, customer feedback — alongside a lightweight pattern of capturing what actually happened, so the agent can read across all of it when the next similar project starts. The same compounding-knowledge shape underwrites documenting your startup's pivot history and first-time founders moving faster on their second project.
The retro that actually gets written
The retrospective fails for two reasons. First, the meeting gets pushed because urgency wins. Second, even when the meeting happens, the output is a doc nobody opens again. The fix addresses both.
A working shape: every project has a top-level page with sub-pages for the brief, the decisions log, the meeting recaps, and a "lessons" sub-page. The lessons sub-page exists from day one, empty. Throughout the project, when a lesson emerges in real time — a vendor who flaked, a scope assumption that didn't hold, a decision that worked better than expected — you drop a one-line entry. Two minutes. Capy supports unlimited page nesting so the lessons sub-page can fan out by category if it gets thick.
By the time the project closes, the lessons page is half-written. The retrospective meeting becomes a curation pass over what's already there, plus one or two surfacings the team adds in the room. The output is shorter, more honest, and gets opened again — because it took twenty minutes instead of two hours to produce. (The capture-while-it's-fresh habit is the same one underwriting a board-of-directors meeting, where waiting until afterward loses too much.)
Decisions that come with rationale
The most useful lesson is rarely "we picked the wrong vendor." It's "we picked the wrong vendor because we anchored on price after the first call and didn't re-evaluate when the scope changed." The rationale is the part that lets the next project avoid the same trap.
A working setup: keep an inline decisions database in the project page via the :::database::: directive — rows for date, decision, rationale, owner, what triggered it, and what we'd want to revisit. After every meaningful decision, ask the agent to propose an entry from the recent meeting recap or chat. You confirm or edit; the entry lands in the database while the rationale is still fresh.
When the retro arrives, the decisions database is the spine of the conversation. You're not asking "what did we decide" — you're asking "which decisions held up and which ones didn't, and what was the pattern." The rationale field is what turns a decisions log into a teachable artifact.
Recordings with speaker labels for the harder retros
Some retros are easy and some aren't. The launch that went well needs an hour and a few bullet points. The launch that went sideways — the one where the team is upset and people are quietly blaming each other — needs a more careful conversation, and nobody wants to be the one taking notes.
Record the meeting in Capy. The transcript comes back with speaker diarization — labels like "Speaker 1: …" so you can tell who said what, not just a wall of unattributed text. Park the recording on the project's lessons page. Ask the agent to draft a recap with three sections: what we agreed went wrong, what we agreed went right, and what we agreed to do differently next time. Pull a list of the followup actions with owners. (The same recording-with-speaker-labels habit shows up in our writeup of coaching sessions and personal growth — different room, same loss pattern.)
The transcript matters less for the meeting itself and more for the next time. Two months later, when somebody on the team says "we decided in the post-mortem to do X," you can search the vault and find the moment in the transcript where it was actually said. The rehashing of "wait, did we agree to that" stops eating future meetings.
Customer feedback that doesn't get lost in Slack
Most projects produce customer feedback you only realize is a lesson in retrospect. The casual remark on a sales call about pricing that you should have priced as a lesson on positioning. The bug report that exposed a scope assumption you hadn't tested. The thank-you email that named a workflow you didn't think you'd shipped.
A working setup: a "customer signal" page in the project vault where you drop quoted snippets from Slack, email, and calls as they land. Two minutes per snippet. Tag the speaker, the date, and a one-line context. By the end of the project, you have a primary-source archive that's much richer than your memory of "customers liked it."
In the retro, ask the agent to read the customer-signal page and surface the patterns: which feedback came up multiple times, which contradicted assumptions you made in the brief, which suggested a follow-on project. The signal stops being lost in the next sprint because the next project starts from a vault that already knows what last project's customers actually said. The account-managers guide covers the same client-context capture habit in a different shape.
The lessons archive across projects
A single project's lessons file is moderately useful. Five projects' lessons across two years is where the compounding kicks in. The patterns that took you three painful projects to internalize are sitting in your vault, ready to be surfaced before the fourth project starts.
A working flow: when you're scoping a new project, ask the agent to search across all your prior project vaults for lessons that touch on the relevant theme — vendor management, scope creep, customer onboarding, hiring during a project. The agent finds the prior lessons and quotes them with a link back to the project they came from. You're not starting blank; you're starting with a personal playbook that's actually built from your own past work.
The same surfacing works on heavier project artifacts. Drop the vendor's post-deployment report, the contractor's final invoice, or the auditor's letter on the project page — they auto-convert to markdown via docstrange so the agent reads them as searchable text. Ask the agent to surface anything in the vendor's report that contradicts what you said in your own recap, or every line item in the final invoice that wasn't in the original SOW. The mechanic is the same one underwriting contract negotiation with AI notes — different artifact, same compounding habit. With the lessons and the supporting documents living as plain markdown, the lookup is one prompt. The pattern of "we keep making this mistake" becomes a question you can actually ask.
What this isn't
Capy doesn't replace your project management tool. The Gantt charts, the ticket queue, the board-state tracking — those still live where they live. Capy is for the unstructured side — the lessons, the rationale, the customer signal, the recap — which is the part that's currently sprawled across Slack threads and meeting notes and your memory.
It's also single-user by design. One operator, one vault. The shape that fits is a founder or PM running their own project history alongside the team's project tools. If your team needs a multi-user retrospective workspace with role-based permissions and shared editing, that isn't this product today. Pricing tiers are on the pricing page.
A small first test
Pick the most recent project you closed. Drop the project brief, the last two meeting recaps, and any customer feedback you have on hand into a Capy page. Ask the agent to draft a one-page lessons-learned summary with three sections: what worked, what didn't, what we'd do differently. If the summary catches something you'd otherwise have forgotten, that's the agent doing for you what the post-mortem meeting was supposed to do — and didn't get scheduled.
Try Docapybara free. Load one finished project and see what falls out.