Skip to content
Skills Library
AI & agents · Writing

context-builder

/context-builder

Generate a CONTEXT.md shared vocabulary for any project. Reduces agent verbosity by 50-75%, improves variable naming, makes conversations more precise. Interviews the user about domain terms, then produces a structured glossary the agent references every session. Use when starting a new project, onboarding to unfamiliar code, the agent is being too verbose, or conversations have too much jargon confusion. Also use when user says "build context", "shared language", "define terms", or "the agent doesn't understand my project vocabulary".

Repository
skill-forge ↗
Licence
MIT
Last repository change
28.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 28.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Generate a CONTEXT.md shared vocabulary for any project. Reduces agent verbosity by 50-75%, improves variable naming, makes conversations more precise. Interviews the user about domain terms, then produces a structured glossary the agent references every session. Use when starting a new project, onboarding to unfamiliar code, the agent is being too verbose, or conversations have too much jargon confusion. Also use when user says "build context", "shared language", "define terms", or "the agent doesn't understand my project vocabulary".

Triggers from the description

build contextshared languagedefine termsthe agent doesn
Original author description

Generate a CONTEXT.md shared vocabulary for any project. Reduces agent verbosity by 50-75%, improves variable naming, makes conversations more precise. Interviews the user about domain terms, then produces a structured glossary the agent references every session. Use when starting a new project, onboarding to unfamiliar code, the agent is being too verbose, or conversations have too much jargon confusion. Also use when user says "build context", "shared language", "define terms", or "the agent doesn't understand my project vocabulary".

How it works

  1. Overview
  2. The Problem This Solves
  3. Process
  4. Verification
  5. Concrete Example
  6. Common Mistakes
  7. Why This Works
Original SKILL.md headings · 116 lines, 638 words
SKILL.md preview
---
name: context-builder
description: >-
  Generate a CONTEXT.md shared vocabulary for any project. Reduces agent verbosity
  by 50-75%, improves variable naming, makes conversations more precise. Interviews
  the user about domain terms, then produces a structured glossary the agent references
  every session. Use when starting a new project, onboarding to unfamiliar code,
  the agent is being too verbose, or conversations have too much jargon confusion.
  Also use when user says "build context", "shared language", "define terms", or
  "the agent doesn't understand my project vocabulary".
---

# Context Builder

## Overview

Create a shared vocabulary between you and the agent. Once built, the agent speaks YOUR language — concise, precise, domain-native.

## The Problem This Solves

Without shared context:
- Agent uses 20 words where your domain has 1 term
- Variables named generically ("data", "handler", "service") instead of domain terms
- Every session starts from scratch explaining the same concepts
- Conversations are verbose because the agent doesn't know your jargon

With CONTEXT.md:
- Agent speaks your domain language natively
- "the materialization cascade" replaces "when a lesson inside a section of a course is made real"
- Code uses domain terms for variables, functions, modules
- Sessions start with shared understanding already loaded

## Process

### 1. Interview (grill the user)

Ask these questions ONE AT A TIME:

1. "What is this project? One sentence."
2. "What are the 3-5 most important CONCEPTS in this domain?"
3. For each concept: "Define it in one sentence. What terms should I AVOID using for this?"
4. "Are there relationships between these concepts? (X contains many Y, Y belongs to one X)"
5. "Any terms that were previously confusing or ambiguous? What did you resolve them to?"
6. "What actions/verbs are specific to this domain?" (e.g., "materialize", "triage", "hydrate")

### 2. Generate CONTEXT.md

Write to the project root:

```markdown
# [Project Name]

[One-sentence description]

## Language

**[Term 1]**:
[Definition in one sentence]
_Avoid_: [terms NOT to use for this concept]

**[Term 2]**:
[Definition]
_Avoid_: [alternatives to avoid]

## Relationships

- A **[Term 1]** contains many **[Term 2]**s
- A **[Term 2]** belongs to one **[Term 1]**

## Flagged Ambiguities

- "[confusing term]" was previously used for both X and Y — resolved: [how it's now used]
```

### 3. Persistence

Once CONTEXT.md exists:
- Agent reads it at session start
- Uses defined terms in ALL communication
- Names variables/functions using the vocabulary
- Flags when new undefined terms appear: "Should I add '[term]' to CONTEXT.md?"

### 4. Evolution

CONTEXT.md grows over time:
- New concepts emerge during development → add them
- Ambiguities surface → resolve and document
- Terms become obsolete → remove them
- The vocabulary becomes MORE precise with each session

## Verification

After generating CONTEXT.md:
- [ ] Every domain concept has exactly ONE term (no synonyms in use)

## Concrete Example

For an e-commerce project, a good CONTEXT.md entry:

```markdown
**Cart**:
A temporary collection of products a customer intends to purchase. Exists per-session, persists across page navigation, cleared on checkout completion.
_Avoid_: basket, bag, order (an Order only exists AFTER checkout)

**SKU**:
The unique identifier for a specific product variant (size + color). NOT the product itself — one Product has many SKUs.
_Avoid_: product ID, item number (SKU is variant-level, product ID is parent-level)
```

This level of precision prevents: wrong variable names (`orderId` when it should be `cartId`), confused queries (joining on product_id when you need sku_id), and verbose explanations ("the thing where users put stuff before buying").
- [ ] Each term has an "Avoid" list (prevents drift back to vague language)
- [ ] Relationships are explicit (not just a flat list)
- [ ] The agent can explain the project using ONLY these terms

## Common Mistakes

- Adding implementation details to CONTEXT.md (it's a GLOSSARY, not a spec)
- Defining too many terms at once (start with 5-8 core terms, grow organically)
- Skipping the "Avoid" list (without it, the agent drifts back to generic language)
- Treating it as write-once (update when new domain concepts emerge)

## Why This Works

Cognitive science: shared mental models reduce communication overhead exponentially. In software, Eric Evans called this "Ubiquitous Language" (Domain-Driven Design). mattpocock proved it works for AI agents with 75% token reduction in practice.

The CONTEXT.md IS the Ubiquitous Language for your human-agent collaboration.

Versions

RepositoryScoreLicence
This page · Adit-Jain-srm/skill-forge100MIT
ThomasSerna/context-builder-skill85MIT

Database snapshot: 13.11.2026 · package version bfb9b5cbf42d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90glossary
    Build or update a CONTEXT.md domain glossary for the current project. Establishes shared vocabulary with term definitions, avoid-aliases, and relationships so agents use consistent, concise language. This skill should be used when starting a new project, when domain terminology…
  • 100project-context-setup
    Scaffolds per-repository agent context so coding agents share the same issue tracker rules, triage label vocabulary, domain glossary, ADR layout, and handoff conventions. Triggers on: "set up project context", "configure agent docs", "create CONTEXT.md", "setup agent workflow",…
  • 90gds-generate-project-context
    Create optimized project-context.md for AI agent consistency. Use when the user says "project context" or "generate context
  • 90gds-generate-project-context
    Create optimized project-context.md for AI agent consistency. Use when the user says "project context" or "generate context
  • 86create-context
    Create the .agentcontext file (a hidden per-project brief that load-context reads and update-context maintains) for the project in the current working directory. Use when the user says "make agent context", "create agent context file", "set up context for this project", or when…
  • 100context-engineering
    Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.