Don't teach your team git. Bring them into the repo.

The problem

SSOT breaks at the origin, not the endpoint.

Every request ends in git. It just doesn't start there. It starts in a spreadsheet, gets retyped into Jira, argued about in Slack, and specced in Confluence. By the time an engineer cuts a branch, the truth lives in five places and none of them agree — and the stale spec is the one somebody ships against.

How it works

No issues. No branches. No merge conflicts.

Your teammates never see git. You never translate another request.

1. 1They write in plain language

   A PM writes a task the way they'd explain it out loud. On save it's markdown in your repo, committed under their own name. They don't know what a commit is, and they don't need to.

2. 2Your agent picks it up

   Claude Code or Cursor reads the task over MCP, with your specs, decisions, and code in the same repo. It comes back with clarifying questions or a draft.

3. 3A human confirms

   Reviewers see a plain-language diff, not red and green code. One click to make it canon, one click to push back.

   

$ claude
> anything waiting for us in kaname?

⏺ kaname · list_stale_documents
  product/pricing-page — a decision it depends on
  changed after this doc was last edited

> draft the fix and send it for review

⏺ kaname · submit_response
  Sent. Your PM sees it as "Needs review" —
  one click to approve, and it lands as a commit.

The moat

Docs that can't quietly go stale.

Docs and code share one repo, so freshness is something kaname can check instead of promise. When the specs and decisions a doc depends on move on, the doc gets flagged. Every doc carries a freshness signal In sync Checking May be outdated and stale ones surface on the home screen before someone trusts them.

Notion can't do this. Confluence can't either. The doc has to live next to the code.

Agent context

Full context for your agents.

Specs, decisions, tasks, and code: one repo. Your agent reads all of it through MCP with no connectors, no API glue, no retrieval pipeline to babysit.

And kaname itself never runs an LLM. Inference happens on your side, on your plan, and your code never passes through ours.

Under the hood

git, fully hidden.

Your teammates see plain words. You see real commits.

GitHub appears exactly once: at sign-in. Every save is a real commit, attributed to the person who made it.

Boundaries

Your source stays out of reach.

kaname reads and writes inside the kaname/ folder of your repo — team docs and personal notes, nothing else. Your source, your engineering docs, your CI config never appear in the workspace. Nobody can break what they never see.

No lock-in

It's just your repo. Always.

kaname is a wrapper around git, not a database you feed. Docs live in your repo as markdown; tasks live in GitHub Issues. Data flows one way — git to cache — and every cache can be rebuilt from the repo.

Cancel, clone, and everything is still yours. One subscription replaces the Jira + Confluence + Notion stack.

Pricing

$15 per seat. Engineers pay nothing.

Questions engineers ask

The fine print, up front.

What does the GitHub App actually get access to?

Repo contents, like any GitHub App that writes. What kaname does with that access is narrow: it reads and writes only inside the kaname/ folder, and every save goes through a short-lived branch merged into main — so it shows up in your history like any other commit, and you can audit all of it.

We already track work in Linear or Jira.

Keep it. kaname is for the product work that ends in your repo — specs, decisions, and the requests behind them. Tasks are plain GitHub Issues under the hood, so nothing forks your existing GitHub flow, and you can start with docs and reviews alone.

One person builds this. What happens if it goes away?

You clone your repo and keep everything: docs as markdown, tasks in GitHub Issues, history in git. kaname's own database is a cache rebuilt from GitHub — there is nothing to export because nothing is trapped.

Does my code pass through your servers or an LLM?

No. kaname runs no LLM, and it never reads outside the kaname/ folder — your source stays between you, GitHub, and the agents you run on your own plan.