The AI coding best practices your team needs already exist — in someone's sessions

Every engineering team using agents for long enough contains its own best practices. Someone has figured out that planning before agentic edits saves a rewrite. Someone delegates research to subagents instead of polluting their main context. Someone turned the deploy dance into a saved command. Someone maintains a memory file so the agent stops re-learning the project every session.

The problem is not that the knowledge doesn't exist. The problem is that nobody else knows it exists.

Why good practices die where they're born

Agent sessions are private by default. A developer works out an effective pattern across a dozen sessions, it becomes second nature to them, and that's where it stops. There's no artifact. Nothing lands in a PR that says "I entered plan mode first and that's why this refactor went cleanly." Standard metrics — PR counts, DORA, seat licenses — can't see it either; the practice is invisible at exactly the layer where it lives.

So discovery happens by accident, if at all: a pairing session, a lucky Slack thread, someone watching over a shoulder. When that developer leaves, the practice leaves with them.

Generic advice doesn't close it. There's no shortage of AI coding best practices content — we wrote a guide to the ones that hold up ourselves. But a list of practices someone else found useful is a weaker starting point than the practices someone on your team is already using successfully, on your codebase, this week. Those come pre-validated. You just can't see them.

What a discoverable record changes

Accrete parses your team's real Claude Code sessions into a durable, queryable record — how it works covers the pipeline. For practice discovery, three layers do the work:

Practice signals show that something works, and who does it. At ingest, every session is classified for concrete behaviors: plan mode, subagent delegation, skills and saved commands, task tracking, memory and context management, committing work, producing markdown artifacts. The per-person × per-practice adoption matrix then shows the spread — and the gaps. If one person uses subagent delegation constantly and seven people never have, that cell is a discovery waiting to happen.

Session drill-down shows how. A matrix cell tells you a practice fired; the session record shows the actual prompts and what the agent did with them. That's the difference between "Priya uses plan mode" and "here is what Priya's planning prompt looks like, and here's the agent executing against it." The how is what's teachable.

The team catalog shows where to look across projects. Each project gets a card summarizing what its recent sessions are actually about. Good patterns usually develop inside one project's walls; the catalog lets a lead scan everyone's actual work in a minute and notice that the payments team solved a workflow problem the platform team is still fighting.

What this looks like in practice

An illustrative scenario — not a customer story; we're pre-launch and don't have those yet.

A lead scanning the adoption matrix notices one engineer's sessions consistently combine plan mode with task tracking on big refactors — a pairing almost nobody else shows. She opens two of those sessions in drill-down and reads the actual flow: a planning pass that surfaces the risky files first, then a tracked task list the agent works through instead of one sprawling prompt. She names the pattern — "plan-then-track for multi-file changes" — demos those two sessions at the next team meeting, and makes it the norm for refactors over a certain size. Over the following weeks, the matrix shows the practice spreading: two adopters, then five, then most of the team.

No survey, no mandate from a blog post. A practice that already worked, found and spread on evidence. The same loop runs deliberately as a coaching motion — that's coach your team.

The honest caveat

A practice signal says a practice was used, not that it was used well. A session can enter plan mode and produce a useless plan. The signal narrows the search — it tells you where to look and who to look at — but the drill-down and a human's judgment decide whether what you found is worth spreading. Accrete makes the discovery cheap; it doesn't make the call for you.

The aggregate patterns we see across real usage feed our research, so what teams learn individually compounds publicly too.

Find what your team already knows

We're pre-launch, working with a small set of teams. Join the early access list — or ask about becoming a design partner when you sign up, and help shape the practice catalog against what your team actually does.