Context Compose

Composable Contexts for High-Quality, AI-Powered Development

Why Context Compose?

While high-level requirements documents (like PRDs) provide overall project goals, they often lack the detailed, task-specific context needed for day-to-day development. Each unit of work—be it a new feature, a bug fix, or a refactor—requires its own focused set of rules, expert perspectives, and guidelines to ensure consistency and quality.

Context Compose provides a simple yet powerful system for defining, composing, and managing these granular contexts. It's like Docker Compose, but for your AI development workflow.

The Problem:

• High-level documents are too broad for specific coding tasks.
• Developers constantly switch between tasks that require different mindsets and rules.
• Inconsistent approaches across team members for similar tasks lead to quality issues.
• Repetitive and manual context-setting for AI assistants is time-consuming.

The Solution: Context Compose allows you to define reusable, task-specific contexts that can be composed on demand. This ensures every task is approached with the right expertise and standards, leading to consistent, high-quality results across your entire team.

Key Features

• 🎯 Task-Specific Contexts: Create dedicated contexts for features, bug fixes, refactoring, API design, and more.
• 🧩 Composable Architecture: Mix and match components—like expert personas, coding rules, and specialized tools—to build the perfect context for any task.
• 🔧 Fully Customizable: The system is built on a simple directory structure. You can override existing assets or create entirely new categories (e.g., security, testing-philosophy) to fit your project's unique needs.
• ⌨️ Simple CLI: A straightforward command-line interface (start-context) makes it easy to load contexts and integrate with your existing workflows.
• 📂 Clear File-Based Structure: All contexts and assets are managed as simple YAML files, making them easy to version control, share, and edit.

MCP Server Integration

To integrate Context Compose with an MCP-compatible client (like an IDE extension), you can register it as an MCP server.

For integration with automated tools, use the following configuration in your settings file:

{
  "mcpServers": {
    "context-compose": {
      "command": "npx",
      "args": ["-y", "@noanswer/context-compose@latest"]
    }
  }
}

This configuration tells the client how to start the context-compose server, ensuring it runs non-interactively.

Project Initialization

Before using contexts, you need to initialize your project. This sets up the necessary .contextcompose directory and default assets.

Copy and paste the following into your prompt to run it.

initialize using context-compose

What happens:

• The init command runs.
• A .contextcompose directory is created in your project root.
• Default assets (personas, rules, etc.) are copied into it, ready for you to use or customize.

How It Works

Context Compose works by reading a main context file and dynamically assembling a final, detailed prompt from various component files. The entire system is driven by a special directory in your project root: .contextcompose/.

1. The .contextcompose/ Directory: When you start a task, you tell Context Compose which context to use (e.g., feature).
2. Main Context File: It looks for a corresponding file, like .contextcompose/feature-context.yaml.
3. The context Block: Inside this file, a context block lists all the components to include. It references other YAML files organized by category (e.g., personas, rules).
4. Dynamic Composition: The tool reads each referenced file, extracts its prompt, and combines everything into a single, comprehensive prompt.

The best part? It's fully extensible. You can create any category you want. If you add a security: section to your context file,

... View full README on GitHub