Core Concepts
teamrc has four building blocks. Each is simple on its own, but understanding how they connect helps you get the most out of them.
Terminology
Member = an AI agent on your team (e.g. architect, reviewer, frontend-dev).
Participant = a human user who joined the team via an invite code.
Owner = the human user who created or claimed the team. Controls sharing and visibility.
Members
A member is an AI agent on your team. Each one has three things:
-
A name, a short identifier like
frontendorreviewer. Used as a filename, so keep it lowercase and hyphenated. - A role, a one-line description of what the agent does. Shown in platform UIs as the agent's subtitle.
- Optional instructions, a detailed markdown block defining the agent's identity and behavior (see below).
What files get generated
When you sync, teamrc creates a configuration file for each member on each platform.
All generated files are prefixed with
trc-
so they're easy to identify
and won't collide with files you create manually.
A member named "frontend" generates:
Catalog vs custom members
You don't have to start from scratch. There's a catalog of 60+ pre-built agents organized by category: development, infrastructure, quality, research, and more. Pick one and it comes with instructions and recommended skills already filled in. Tweak it or use it as-is.
Or create a fully custom member with just a name and role. Up to you.
Skills
Skills are reusable instruction blocks that you write once and assign to the agents that need them. Things like "always write tests," "follow our code style," or "review for security vulnerabilities." Instead of copying the same rules into every agent's instructions, you define them once at the team level.
How assignment works
Skills live on the team, not on individual agents.
You explicitly assign each skill to the agents that should use it.
So your frontend agent might get
code-style
and
accessibility
,
while your reviewer gets
code-review
and
testing
.
Different agents, different skills.
Always-apply skills
Some rules should apply to everyone. Set
alwaysApply: true
and the skill
automatically applies to every agent
on the team. You don't need
to assign it individually.
This is great for things like commit message formats, security policies, or project-wide style guides.
File-targeted skills
Skills can also target specific files. Add
globs
like
*.tsx
or
src/api/**
and the skill only activates when the agent
is working on matching files. Useful for language-specific or directory-specific rules.
Skill properties
id
Required. A unique identifier like
code-review
. Used as a filename.
title
Optional. A human-readable label.
body
Required. The instructions themselves, written in markdown.
alwaysApply
When true, applies to all agents without explicit assignment.
globs
File patterns. The skill activates only for matching files (on supported platforms).
Pre-built skills
Like agents, there's a catalog of ~50 pre-built skills you can pick from: code quality, testing, documentation, security, and more. Use them as-is, tweak them, or write your own.
Instructions
Each agent can have instructions
(the
soul
field in
.teamrc.yaml
):
a free-form markdown block that tells the agent who it is, how it should behave, and what
it should focus on. Think of it as the agent's personality and expertise description.
Instructions vs skills
Instructions are unique to one agent. They define who it is. Skills are shared across agents. They define what rules to follow. A frontend agent's instructions might say "you specialize in React and accessibility." A skill assigned to that agent might say "always write unit tests for new components."
When you pick a catalog agent, instructions are pre-filled with sections covering:
- Identity: who the agent is and its core purpose
- Expertise: what it specializes in
- Principles: how it approaches work
- Communication: how it interacts with you
You can edit these freely after adding the agent, or write your own from scratch.
Knowledge
Knowledge is a shared document that every agent on the team can read and write to. It's where agents record things they learn while working: "the auth service requires header X," "don't touch the legacy module, it's being replaced," "the CI takes 8 minutes, cache the build."
Knowledge content is automatically injected into every agent's context via the
team-knowledge
skill (an
alwaysApply
rule).
No manual reading is required — agents see the latest knowledge at the start of every session.
Unlike instructions or skills, you don't write knowledge upfront. It builds up naturally
as agents work on your codebase. When you sync, knowledge from all machines gets merged
together, so every agent benefits from what the others have learned.
Built-in slash commands
teamrc installs slash commands in editors that support them (Claude Code, Cursor):
## <topic>
section (prunable)Preamble vs. sections
The knowledge file has two zones. The preamble (everything before the first
##
heading, up to 10KB) is permanent — it is never pruned. Use it for essentials like
test commands, architecture notes, and key conventions. Sections
(
## <topic>
headings) are pruned oldest-first (FIFO) when the file exceeds 100KB.
How knowledge merges
Knowledge uses append-only deduplication.
When syncing, new lines from the relay are appended to your local knowledge file,
skipping anything already present. When the file exceeds 100KB, the oldest
##
sections are pruned automatically. The preamble is always preserved.