This is complete and verified — 994 words of body prose (within the 800-1100 target, confirmed via word count), single frontmatter block matching the required schema, one illustrative code block, both citations quoted verbatim from the provided evidence and linked to their real URLs (no invented sources), no fabricated statistics, and an honesty section on what Lycato does not do. Draft file: `C:\Users\aksha\AppData\Local\Temp\claude\C--Users-aksha-Desktop-RunningProjects\348e7d45-c567-4f91-9ef2-80ca10a97557\scratchpad\decisions-that-evaporate.md`

---
title: "The decision you made in Slack is gone: an audit trail for a one-person company"
slug: "decisions-that-evaporate"
dek: "Chat is where decisions get made and where they quietly disappear; Lycato turns every approval into a timestamped, attributed git commit, so the record exists because the decision did."
audience: "Solo and small-team founders running parts of their company through AI agents, who need a real paper trail without hiring someone to keep one."
tags: [decisions, audit-trail, git, compliance, solopreneur]
---

## The record was never being kept

You approved the contractor's rate increase in a DM. You told an agent, in a Slack thread, to go ahead and sign the new vendor contract. Six months later that thread is buried under everything else that happened since, or the workspace rotated off its history limit, and you're looking at a line item on the P&L you don't fully remember agreeing to.

A commenter on Hacker News named this pattern precisely: ["decisions are made, tasks are implied, commitments are spoken and then dissipate"](https://news.ycombinator.com/item?id=47219084). That's not a complaint about being careless. It's a description of chat as a storage medium — good for coordinating in the moment, bad at holding on to the reasoning behind a choice once the moment has passed.

For a company of one, "tribal knowledge" is an odd phrase. There's no tribe, just you. But the failure is the same, arguably worse: there's no second person who half-remembers why something happened. When your own memory compresses a decision down to the outcome and drops the reasoning, there's nobody to check it against. And the person asking isn't always future-you — it's an accountant reconciling the books, a lawyer doing diligence, an investor asking why churn moved the same month you changed pricing.

## Three days digging through email

A solopreneur on [r/projectmanagement](https://www.reddit.com/r/projectmanagement/comments/1hm0h3g/) described the same failure from the other side — the moment someone outside your head asks for the record. Their reason for wanting a single source of truth: when the auditor asks for supporting documentation, as they put it, "you spend three days digging through email" trying to reconstruct what happened and who signed off on it.

Three days is the tax on not having kept a record at the moment the decision was made. It isn't a cost that hits you because you were disorganized. It hits you because the format — a DM, a thread, a verbal yes — was never designed to be looked up later. Nothing about a Slack message resists being found on purpose; it just wasn't built to be found, and by month six that's the same thing.

## Git already solved this, for code

Version control solved this exact problem for code a long time ago. A commit has an author, a timestamp, a message, and a diff: the state before, the state after, and a stated reason for the change. Nobody has to remember whether something was reviewed, or by whom — `git log` says so, permanently, and rewriting that history is itself a loud, visible act.

Lycato applies the same structure to running the company, not just the codebase. The company is a git repo: people, money, obligations, and decisions live in it as plain markdown. When something needs a decision — renew a vendor, change a price, pass on a deal, bring on a contractor — the change shows up as a diff, whether you wrote it yourself or an AI agent drafted it from context it already had access to. You read the diff. You merge it, or you don't. Nothing ships unreviewed — that's as true for a decision entry as it is for anything else in the repo. If you do merge it, git records who did that and when, permanently attached to what was decided and why.

## What it looks like

In practice, an approval produces a small file and a commit, not a new tool you have to remember to update:

```
commit 8f2a91c
Author: Akshay Sarode <akshay@akshaysarode.com>
Date:   Mon Jul 6 14:02:11 2026 -0400

    approve: renew Vercel enterprise, $12,000/yr

diff --git a/decisions/2026-07-06-renew-vercel.md b/decisions/2026-07-06-renew-vercel.md
new file mode 100644
+++ b/decisions/2026-07-06-renew-vercel.md
@@
+---
+status: approved
+approved_by: akshay
+amount: 12000
+---
+Renewing instead of migrating to self-hosted infra. Migration
+saves ~$8k/yr but costs two weeks of engineering time we don't
+have before the fundraise. Revisit at next renewal.
```

The commit hash, author, and timestamp aren't decoration added for compliance. They're the mechanism the approval happened through — you can't merge a diff without them existing.

That's what makes the record greppable instead of something you reconstruct later. "What did I decide about vendor spend in Q2" is `git log --since=2026-04-01 -- decisions/`. "Who approved this" is reading one commit, because the file has exactly one line of history, not a group chat's worth.

Day to day this doesn't mean living in a terminal. An agent opens the proposed decision in Lycato's Cockpit, in the Review pane, next to the ledger change or obligation it's attached to. You read it, and you approve it or you don't. The commit is a side effect of that approval, not a form you fill out afterward because you remembered to.

## What this doesn't do

Lycato doesn't listen to Slack and log your decisions for you. If the only place something was ever decided is a DM, it's still gone — there's nothing to retroactively capture, and Lycato doesn't invent a record after the fact. What changes is the cost of doing it right the next time: the same agents already touching your ledger and your obligations file are the ones drafting the decision entry, so writing down the reasoning at the moment you say yes is nearly free, instead of a habit you have to maintain on top of everything else you're doing.

It's also not a substitute for whatever your jurisdiction actually requires of you — signed contracts, board resolutions, statutory minutes. A markdown file with your name on a commit is a working record of reasoning, not a legal instrument, and the two shouldn't be confused.

And it only works if approvals actually route through it. Lycato can't stop you from saying yes in a Slack thread anyway — nothing can. It just makes the disciplined path, propose then review then merge, cheaper than the sloppy one. That's the only kind of change to a habit that tends to survive a busy week.

## The takeaway

An audit trail isn't bureaucracy for a company of one. It's memory that outlives you forgetting, and a record that doesn't depend on you being the one who eventually gets asked. Git already had the primitive: a commit with an author, a timestamp, and a diff. Lycato just points it at your decisions instead of your code, so "what was approved, and why" is a query you run, not an investigation you dread.
