Orchestre

Appearance

Tutorial 1: Your First Orchestre Project ​

Overview ​

Now that you've seen how to generate a custom implementation tutorial, let's dive deeper into how Orchestre works by creating a project from scratch. This tutorial focuses on understanding Orchestre's context intelligence and memory system—the secret sauce that makes your AI truly understand your project.

Learning Objectives ​

By the end of this tutorial, you will:

  • [ ] Create a new project using Orchestre templates
  • [ ] Understand how Orchestre's memory system provides context
  • [ ] See how AI discovers and adapts to your patterns
  • [ ] Experience the difference context makes in AI output
  • [ ] Build a working application with context-aware assistance

Prerequisites ​

Before starting this tutorial, you should:

  • Have Orchestre installed and configured in Claude Code's MCP settings
  • Have Node.js 18+ installed
  • Have basic familiarity with web development

Duration ​

Estimated time: 30 minutes

Step 1: Create Your First Project ​

Let's create a simple blog application to understand how Orchestre's context system works. We'll use this as a learning playground.

Action ​

In Claude Code, type:

/orchestre:create (MCP) cloudflare-hono my-blog

Note: If you already created a project from your implementation tutorial, you can explore that instead!

Understanding ​

This prompt:

  • Invokes the initialize_project MCP tool directly
  • Selects the Cloudflare Hono template (great for APIs)
  • Creates a complete project structure
  • Sets up distributed memory system (CLAUDE.md files)
  • No file installation needed - prompts work immediately!

Result ​

You should see:

  • Project created in my-blog/ directory
  • Dependencies installed
  • Memory files created (CLAUDE.md and .orchestre/CLAUDE.md)
  • Initial git repository created
  • Ready to use with all Orchestre prompts available

Step 2: Explore the Memory System ​

Let's understand Orchestre's distributed memory architecture.

Action ​

bash
cd my-blog
ls -la

Understanding ​

Your project includes:

my-blog/
├── src/              # Source code
├── CLAUDE.md         # Root project memory
├── .orchestre/       # Orchestration workspace
│   ├── CLAUDE.md     # Orchestration-specific memory
│   ├── knowledge/    # Discovered patterns
│   ├── plans/        # Generated plans
│   └── memory-templates/ # Documentation templates
├── package.json      # Node.js dependencies
└── wrangler.toml     # Cloudflare configuration

The Memory System ​

Orchestre uses a distributed memory system:

  1. Root CLAUDE.md - Main project context that Claude Code reads automatically
  2. .orchestre/CLAUDE.md - Orchestration-specific knowledge and state
  3. Feature-specific CLAUDE.md files - Context colocated with code

Explore CLAUDE.md ​

Open and read CLAUDE.md. This is where the magic happens—it's your project's "brain" that helps AI understand your specific context.

bash
# Open in your editor
code CLAUDE.md

What You'll Find ​

The CLAUDE.md file contains:

  • Project overview and purpose
  • Architecture decisions
  • API patterns and conventions
  • Development guidelines
  • A living document that grows with your project

Step 3: Plan Your Blog Features ​

Now let's use Orchestre's intelligent planning prompt.

Action ​

Simply type in Claude Code:

/orchestre:orchestrate (MCP) Build a simple blog API with:
- Article CRUD operations
- Categories and tags
- Author profiles
- Comment system
- Search functionality

Understanding ​

This prompt:

  • First discovers your project context by reading CLAUDE.md files
  • Analyzes requirements using the Gemini-powered tool
  • Adapts the plan to Cloudflare Hono patterns it finds
  • Updates memory with planning insights
  • Creates a truly contextual plan

Result ​

Orchestre will:

  1. Discover Context - Read your project's memory files
  2. Analyze Complexity - Understand the full scope
  3. Generate Adaptive Plan - Tailored to your specific setup
  4. Update Memory - Save insights to .orchestre/plans/
  5. Suggest Next Steps - Context-aware commands to execute

Step 4: Implement the First Feature ​

Let's implement the article management system using context-aware execution.

Action ​

Type this prompt:

/orchestre:execute-task (MCP) Create article CRUD API with validation

Understanding ​

Watch as this prompt:

  • First explores your codebase to understand patterns
  • Discovers Cloudflare Hono conventions in your template
  • Creates consistent database schema
  • Implements API endpoints following found patterns
  • Adds validation matching your project style
  • Updates CLAUDE.md with implementation decisions

The Discovery Process ​

The prompt doesn't assume - it discovers:

  1. Reads existing code structure
  2. Identifies naming conventions
  3. Finds validation patterns
  4. Adapts to your specific setup

Result ​

New files created following discovered patterns:

  • src/routes/articles.ts - API endpoints
  • src/models/article.ts - Data model
  • src/validators/article.ts - Input validation
  • Updated CLAUDE.md with new API documentation

Step 5: Review Your Code ​

Let's use multi-LLM review for diverse perspectives.

Action ​

Type:

/orchestre:review (MCP)

Understanding ​

This powerful prompt:

  • Discovers recent changes in your codebase
  • Sends relevant code to multiple AI models via MCP tool
  • Gets diverse perspectives (security, performance, patterns)
  • Builds consensus on improvements
  • Updates review results to .orchestre/reviews/
  • Provides actionable, context-aware feedback

Result ​

You'll receive:

  • Security analysis from one perspective
  • Performance suggestions from another
  • Code quality feedback with consensus
  • Architectural recommendations
  • All saved to memory for future reference

Step 6: Add Another Feature ​

Let's add comments - watch how Orchestre learns from your patterns.

Action ​

/orchestre:execute-task (MCP) Add nested comment system with moderation

Understanding ​

Notice how this prompt:

  • Reads the article implementation you just created
  • Learns from your code style and patterns
  • Reuses your validation approach
  • Maintains consistency automatically
  • Integrates seamlessly with existing APIs
  • Documents the relationships in memory

Step 7: Test Your API ​

Let's verify everything works.

Action ​

bash
# Start the development server
npm run dev

# In another terminal:
curl http://localhost:8787/api/articles

Understanding ​

The Cloudflare Hono template includes:

  • Hot reloading
  • Type safety
  • Edge runtime simulation
  • API documentation

Step 8: Update Project Memory ​

Let's capture what we've learned in the distributed memory system.

Action ​

/learn Implemented blog API with articles and comments. 
Key patterns: RESTful design, nested resources, input validation.
Next steps: Add authentication and search.

Understanding ​

This prompt:

  • Analyzes your recent work
  • Extracts key patterns and decisions
  • Updates multiple CLAUDE.md files appropriately
  • Creates knowledge entries in .orchestre/knowledge/
  • Ensures future prompts understand your project evolution

Memory Integration ​

The memory system ensures:

  • Claude Code remembers your patterns across sessions
  • Each feature builds on previous knowledge
  • Team members can understand decisions
  • AI assistance improves over time

Troubleshooting ​

Common Issues ​

Issue: "MCP tool not found" error

  • Solution: Ensure Orchestre is configured in Claude Code's MCP settings
  • Check that the MCP server is running: type /mcp in Claude Code

Issue: Prompts not discovering context

  • Solution: Ensure you're in the project directory with CLAUDE.md files
  • The prompts need to find memory files to work effectively

Issue: API not starting

  • Solution: Check npm install completed successfully
  • Verify all dependencies are installed

Summary ​

Congratulations! In this tutorial, you:

  • ✅ Created your first Orchestre project with prompt-based workflow
  • ✅ Experienced context discovery and adaptation
  • ✅ Used multi-LLM code review for diverse perspectives
  • ✅ Built a working API that learns from your patterns
  • ✅ Integrated with the distributed memory system

Key Takeaways ​

  1. Prompts Available Immediately: No file installation needed - just type and go
  2. Discovery Over Prescription: Prompts explore and adapt to your project
  3. Memory-Driven Development: CLAUDE.md files create persistent context
  4. Pattern Learning: Each feature builds on discovered patterns
  5. True AI Collaboration: Claude thinks about your specific project

Next Steps ​

Challenge ​

Try this discovery-based prompt:

/orchestre:execute-task (MCP) Analyze the current API and add full-text search that matches our patterns

Notice how it first discovers your implementation before adding the feature!

Resources ​

Built with ❤️ for the AI Coding community, by Praney Behl

Copyright © 2025 Orchestre