Your First Orchestre Project

🎆 New Approach Available!

We now recommend starting with the Generate Your Implementation Tutorial command, which creates a personalized guide for YOUR specific project instead of a generic example. This page remains for those who prefer the traditional approach.

Let's create your first project with Orchestre! This tutorial will walk you through building a simple blog application, demonstrating how Orchestre's dynamic prompts adapt to your needs.

What We'll Build

We'll create a modern blog with:

• 📝 Article management (create, edit, delete)
• 👤 User authentication
• 💬 Comments system
• 🎨 Responsive design
• 🚀 Ready for deployment

Step 1: Initialize the Project

In Claude Code, use the /create command to initialize a new project:

/create cloudflare my-blog

Orchestre will:

1. Analyze available templates
2. Set up the project structure
3. Create initial configuration
4. Make all commands available via MCP prompts

You'll see output like:

🎭 Initializing Orchestre project...
📋 Selected template: cloudflare-hono
✅ Project created at: ./my-blog
🚀 All Orchestre commands ready to use!

🎉 New in v5.0: No Command Installation!

Starting with Orchestre v5.0, commands are native MCP prompts. They work immediately without any installation in your project!

Step 2: Define Your Requirements

Create a requirements file describing what you want to build:

Create a file called requirements.md with:

# My Blog Requirements

## Core Features
- Article CRUD operations (Create, Read, Update, Delete)
- User authentication with email/password
- Comment system with nested replies
- Admin panel for content management
- RSS feed generation
- Search functionality

## Technical Requirements
- Fast page loads (< 2s)
- SEO optimized
- Mobile responsive
- Markdown support for articles
- Image uploads with optimization

## Nice to Have
- Social media sharing
- Email notifications for comments
- Analytics integration

Step 3: Analyze and Plan

Now let Orchestre analyze your requirements and create a development plan:

/orchestrate requirements.md

Orchestre will:

• 🔍 Analyze project complexity
• 🎯 Identify key technical challenges
• 📋 Create a phased implementation plan
• 💡 Suggest best practices

Example output:

📊 Project Analysis Complete

Complexity: Medium (Score: 6.2/10)
- Authentication system: 2.5
- Content management: 2.0
- Comment system: 1.7

Recommended Approach:
- Phase 1: Core blog functionality (2-3 hours)
- Phase 2: Authentication system (1-2 hours)
- Phase 3: Comments & interactions (1-2 hours)
- Phase 4: Polish & deployment (1 hour)

Key Technologies:
- Hono for API routing
- Cloudflare D1 for database
- Workers KV for caching
- React for admin panel

Step 4: Execute the Plan

Start implementing the first phase:

/execute-task "Set up core blog functionality with articles API"

Watch as Claude Code:

• Creates the database schema
• Implements API endpoints
• Sets up data models
• Adds validation logic

🤖 Claude Code in Action

// Generated by Orchestre - src/routes/articles.ts
import { Hono } from 'hono'
import { z } from 'zod'
import { getDB } from '../lib/database'

const articleSchema = z.object({
  title: z.string().min(1).max(200),
  slug: z.string().regex(/^[a-z0-9-]+$/),
  content: z.string().min(10),
  excerpt: z.string().max(300).optional(),
  published: z.boolean().default(false),
})

export const articles = new Hono()
  .get('/', async (c) => {
    const db = getDB(c.env)
    const articles = await db
      .selectFrom('articles')
      .where('published', '=', true)
      .orderBy('created_at', 'desc')
      .selectAll()
      .execute()
    
    return c.json({ articles })
  })
  .post('/', async (c) => {
    const body = await c.req.json()
    const validated = articleSchema.parse(body)
    
    // Implementation continues...
  })

Step 5: Review Your Code

After implementing core features, run a multi-LLM review:

/review

This triggers:

• 🔍 Security analysis by GPT-4
• 📊 Performance review by Claude
• 🏗️ Architecture assessment by Gemini
• ✅ Consensus recommendations

Example review output:

🔍 Multi-LLM Code Review

Security (GPT-4): ⚠️ 2 issues found
- Missing rate limiting on API endpoints
- Consider adding CSRF protection

Performance (Claude): ✅ Good
- Efficient database queries
- Proper caching implementation
- Consider adding pagination

Architecture (Gemini): ✅ Excellent
- Clean separation of concerns
- Well-structured API routes
- Good error handling patterns

Consensus: Ready for next phase with minor improvements

Step 6: Iterate and Improve

Continue building features:

/execute-task "Add user authentication with JWT"

/execute-task "Implement comment system with nested replies"

Each task builds upon the previous work, with Orchestre maintaining context and consistency.

Step 7: Deploy Your Project

When ready to deploy:

/execute-task "Prepare for production deployment"

Orchestre will:

• Set up environment variables
• Configure production builds
• Create deployment scripts
• Add monitoring setup

Your Blog is Ready! 🎉

Congratulations! You've built a complete blog application with:

• ✅ RESTful API with Cloudflare Workers
• ✅ Database with D1
• ✅ Authentication system
• ✅ Comment functionality
• ✅ Admin panel
• ✅ Production-ready configuration

Key Takeaways

1. Dynamic Adaptation

Notice how Orchestre adapted to your specific requirements rather than following a rigid template.

2. Intelligent Planning

The phased approach broke down complexity into manageable chunks.

3. Quality Assurance

Multi-LLM reviews caught issues before they became problems.

4. Context Awareness

Each command built upon previous work, maintaining consistency.

What's Next?

Now that you understand the basics, we recommend:

🎆 Generate Your Own Tutorial

Create a personalized guide for YOUR project idea

🧠 Understanding Dynamic Prompts

Learn how Orchestre's prompts adapt to your project

🚀 Building a SaaS with MakerKit

Create a full-featured SaaS application

Pro Tips

💡 Use Natural Language

Don't worry about perfect syntax. Orchestre understands natural descriptions like "add a way for users to reset their password" just as well as technical specifications.

🔄 Iterate Frequently

Run /review after each major feature. Catching issues early is always easier than fixing them later.

📝 Document as You Go

Use /update-state to record important decisions and /document-feature to create documentation alongside your code.