Kilo Code: Understanding Modes and the Orchestrator

1. Understand the request
2. Analyze the codebase context
3. Create a step-by-step plan
4. Execute each step (using appropriate modes)
5. Verify the results
6. Report completion

User: "Add user authentication to our Express.js app"

Orchestrator Response:
I'll help you add user authentication. Here's my plan:

Phase 1: Architecture (Architect Mode)
- Design the authentication flow
- Choose between JWT vs sessions
- Plan database schema for users

Phase 2: Implementation (Code Mode)
- Install required dependencies (jsonwebtoken, bcrypt)
- Create user model with password hashing
- Build registration endpoint
- Build login endpoint
- Create authentication middleware

Phase 3: Testing (Debug Mode)
- Write unit tests for auth functions
- Test login/logout flow
- Verify token validation

Shall I proceed with this plan?

{
  "orchestrator": {
    "autoPlan": true,
    "requireApproval": false,
    "maxSteps": 10,
    "delegateToSpecialists": true,
    "verboseLogging": false
  }
}

# CLI
kilo-code --mode orchestrator "Migrate our database from MongoDB to PostgreSQL"

# In IDE, use the mode selector or type:
/mode orchestrator

User: "Design a microservices architecture for our e-commerce platform"

Architect Response:
## Proposed Architecture

### Services
1. **API Gateway** (Kong/Express)
   - Route requests to appropriate services
   - Handle authentication and rate limiting

2. **Product Service** (Node.js + PostgreSQL)
   - Product catalog management
   - Search and filtering
   - Inventory tracking

3. **Order Service** (Node.js + PostgreSQL)
   - Order creation and management
   - Order status tracking
   - Integration with payment service

4. **Payment Service** (Python + Stripe API)
   - Payment processing
   - Refund handling
   - Webhook management

5. **User Service** (Node.js + Redis)
   - User authentication (JWT)
   - Session management
   - Profile management

### Communication Pattern
- Synchronous: REST APIs for user-facing operations
- Asynchronous: RabbitMQ for order processing events

### Data Flow
[Client] → [API Gateway] → [Services] → [Databases]
                      ↓
                 [RabbitMQ]
                      ↓
            [Analytics Service]

### Technology Recommendations
- Container orchestration: Kubernetes
- Service mesh: Istio (for production)
- Monitoring: Prometheus + Grafana
- Logging: ELK Stack

Shall I create detailed API specifications for each service?

# Generate architecture diagram (Mermaid format)
/architect --output mermaid "Design a CI/CD pipeline"

# Generate API specification (OpenAPI/Swagger)
/architect --output openapi "Design REST API for blog posts"

# Generate database schema (SQL)
/architect --output sql "Design schema for social media app"

# Generate decision document (Markdown)
/architect --output markdown "Choose between Redis and Memcached"

{
  "architect": {
    "defaultOutputFormat": "markdown",
    "includeDiagrams": true,
    "considerSecurity": true,
    "considerScalability": true,
    "maxServices": 10
  }
}

# CLI
kilo-code --mode architect "Design the database schema for a task management app"

# In IDE
/mode architect
/design our new feature flag system

User: "Implement the user registration endpoint we designed"

Code Mode Response:
I'll implement the user registration endpoint based on the architecture.

## Files to Create/Modify

### 1. models/User.js (NEW)
```javascript
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true
  },
  password: {
    type: String,
    required: true,
    minlength: 8
  },
  name: {
    type: String,
    required: true,
    trim: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// Hash password before saving
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 12);
  next();
});

// Compare password method
userSchema.methods.comparePassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

const express = require('express');
const router = express.Router();
const User = require('../models/User');
const jwt = require('jsonwebtoken');

router.post('/register', async (req, res) => {
  try {
    const { email, password, name } = req.body;
    
    // Check if user exists
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ error: 'Email already registered' });
    }
    
    // Create user
    const user = new User({ email, password, name });
    await user.save();
    
    // Generate JWT
    const token = jwt.sign(
      { userId: user._id },
      process.env.JWT_SECRET,
      { expiresIn: '7d' }
    );
    
    res.status(201).json({
      message: 'User registered successfully',
      token,
      user: {
        id: user._id,
        email: user.email,
        name: user.name
      }
    });
  } catch (error) {
    res.status(500).json({ error: 'Server error' });
  }
});

module.exports = router;

// Add this import
const authRoutes = require('./routes/auth');

// Add this route registration
app.use('/api/auth', authRoutes);

### Code Mode Features

**Smart Diff Preview:**
Before applying changes, Code Mode shows a diff:

```diff
--- a/app.js
+++ b/app.js
@@ -5,6 +5,8 @@ const express = require('express');
 const cors = require('cors');
 const mongoose = require('mongoose');
 
+const authRoutes = require('./routes/auth');
+
 const app = express();
 
 app.use(cors());
@@ -15,6 +17,8 @@ app.use(express.json());
 // Routes
 app.use('/api/users', userRoutes);
 
+app.use('/api/auth', authRoutes);
+
 // Error handling
 app.use((err, req, res, next) => {
   console.error(err.stack);

{
  "code": {
    "autoFormat": true,
    "generateTests": true,
    "addComments": true,
    "preferFunctional": false,
    "maxFilesPerRequest": 10,
    "backupBeforeModify": true
  }
}

# CLI
kilo-code --mode code "Implement the password reset functionality"

# In IDE
/mode code
/create the user profile component

User: "Our API is returning 500 errors on the /checkout endpoint"

Debug Mode Response:
I'll investigate the /checkout endpoint issue.

## Step 1: Analyze Error Logs

Found these errors in the last hour:

```
Error: Cannot read properties of undefined (reading 'price')
    at calculateTotal (/app/services/order.js:45:23)
    at checkoutHandler (/app/routes/checkout.js:28:18)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
```

## Step 2: Examine the Code

**File: /app/services/order.js:45**
```javascript
function calculateTotal(items) {
  let total = 0;
  for (const item of items) {
    total += item.price * item.quantity;  // Line 45 - error here
  }
  return total;
}
```

## Root Cause

The `items` array contains products where `price` is sometimes `undefined`.
This happens when products are loaded without their pricing information.

## Step 3: Check Related Code

**File: /app/routes/checkout.js**
```javascript
async function checkoutHandler(req, res) {
  const cart = await getCart(req.user.id);
  const items = await getProducts(cart.itemIds);  // Missing price join
  const total = calculateTotal(items);
  // ...
}
```

## Proposed Fix

```diff
--- a/app/services/order.js
+++ b/app/services/order.js
@@ -1,8 +1,12 @@
 function calculateTotal(items) {
   let total = 0;
   for (const item of items) {
-    total += item.price * item.quantity;
+    if (!item.price) {
+      throw new Error(`Product ${item.id} has no price`);
+    }
+    total += item.price * item.quantity;
   }
   return total;
 }
```

```diff
--- a/app/routes/checkout.js
+++ b/app/routes/checkout.js
@@ -5,7 +5,7 @@ async function checkoutHandler(req, res) {
   const cart = await getCart(req.user.id);
-  const items = await getProducts(cart.itemIds);
+  const items = await getProducts(cart.itemIds, { include: 'pricing' });
   const total = calculateTotal(items);
   // ...
 }
```

## Verification

I'll run the checkout tests to verify the fix:

```bash
$ npm test -- checkout
✓ checkout should calculate total correctly
✓ checkout should handle missing prices
✓ checkout should create order

All tests passed!
```

Apply these fixes?

# Run with specific debugger
/debug --tool lldb "Investigate the segmentation fault"

# Analyze logs
/debug --tool logs "Find errors in the last hour"

# Profile performance
/debug --tool profiler "Find slow database queries"

# Check memory leaks
/debug --tool heap "Analyze memory usage"

{
  "debug": {
    "autoRunTests": true,
    "collectLogs": true,
    "maxLogLines": 500,
    "enableProfiling": false,
    "breakOnFirstError": false
  }
}

# CLI
kilo-code --mode debug "The tests are failing with TypeError"

# In IDE
/mode debug
/fix the build error

/mode orchestrator
/mode architect
/mode code
/mode debug

User: "Build a complete authentication system"
Orchestrator: "I'll plan this (Architect), then implement (Code), then test (Debug)"

# Set mode for session
kilo-code --mode architect

# One-time mode switch
kilo-code "/mode code Implement the login function"

# Mode with specific options
kilo-code --mode debug --tool logs "Find the error"

// .kilocode/config.json
{
  "defaultMode": "orchestrator",
  "modeByTask": {
    "design": "architect",
    "implement": "code",
    "fix": "debug",
    "plan": "orchestrator"
  }
}

// .kilocode/modes/security-review.json
{
  "name": "security-review",
  "baseMode": "architect",
  "systemPrompt": "You are a security expert reviewing code for vulnerabilities.",
  "tools": ["code-scanner", "dependency-checker", "secret-detector"],
  "restrictions": {
    "cannotModifyFiles": true,
    "mustCiteOWASP": true
  }
}

kilo-code --mode security-review "Audit our authentication code"

Good: "Build a complete blog platform with user authentication"
(The Orchestrator will plan and delegate appropriately)

Good: "Should we use MongoDB or PostgreSQL for our analytics platform?"
(The Architect will provide a detailed comparison)

Good: "Implement the blog post CRUD endpoints based on our design"
(Code mode will write the actual implementation)

Good: "The login endpoint returns 401 for valid credentials"
(Debug mode will investigate and fix)

Bad: Asking Code mode to design architecture
Bad: Asking Architect mode to write implementation

Session: Add password reset functionality

1. [Orchestrator] Receives request, creates plan
   "I'll design (Architect), implement (Code), and test (Debug)"

2. [Architect] Designs the flow
   - Email template design
   - Token generation strategy
   - API endpoint design
   - Security considerations

3. [Code] Implements the design
   - Creates reset token model
   - Builds email service integration
   - Implements /forgot-password endpoint
   - Implements /reset-password endpoint

4. [Debug] Tests and verifies
   - Runs unit tests
   - Tests email delivery (mocked)
   - Verifies token expiration
   - Checks for security issues

5. [Orchestrator] Reports completion
   "Password reset feature complete. All tests passing."