sypha "Create a REST API endpoint for user registration"

sypha "Add unit tests for src/utils/validation.js"

sypha "Refactor the authentication module to use async/await instead of callbacks"

sypha "@screenshot.png What are the accessibility issues in this UI?"

sypha "@architecture-diagram.png Explain this system architecture"

sypha "@"designs/mobile-app.png" Compare this design to our current implementation"

# Inside Sypha CLI
> /add src/auth/*.ts
> /commit "Add JWT authentication module"
> /push

> /diff
> /diff --staged

> /undo

sypha "Create a RESTful API for a blog with posts, comments, and users. Use Express.js and TypeScript."

sypha "Create a reusable DataTable component with sorting, filtering, and pagination. Use TypeScript and Tailwind CSS."

sypha "Create a PostgreSQL schema for an e-commerce platform with products, orders, customers, and inventory tracking."

sypha "Refactor src/legacy/user-service.js to TypeScript with proper types and modern async/await patterns"

function getUser(id, callback) {
  db.query('SELECT * FROM users WHERE id = ?', [id], function(err, results) {
    if (err) return callback(err);
    callback(null, results[0]);
  });
}

async function getUser(id: string): Promise<User> {
  const results = await db.query<User>('SELECT * FROM users WHERE id = $1', [id]);
  return results[0];
}

sypha "Extract repeated validation logic from src/controllers/*.ts into reusable utility functions"

sypha "Split src/app.ts into separate modules following the single responsibility principle"

sypha "Generate comprehensive unit tests for src/services/payment.ts using Jest"

// src/services/payment.test.ts
describe('PaymentService', () => {
  describe('processPayment', () => {
    it('should process valid payment successfully', async () => {
      // Test implementation
    });

    it('should reject invalid card numbers', async () => {
      // Test implementation
    });

    it('should handle payment gateway timeouts', async () => {
      // Test implementation
    });
  });
});

sypha "Create integration tests for the authentication API endpoints using supertest"

sypha "Write Playwright E2E tests for the user registration flow"

sypha "Generate OpenAPI/Swagger documentation for all API routes in src/routes/"

sypha "Create a comprehensive README.md for this project with setup instructions, architecture overview, and usage examples"

sypha "Add JSDoc comments to all functions in src/utils/ explaining parameters, return values, and usage"

sypha "@error.log Analyze these error logs and identify patterns. What's the root cause?"

sypha "The API /api/users endpoint is slow. Profile it and suggest optimizations."

sypha "I'm seeing increasing memory usage in the Node.js app. Help me find the leak."

sypha "Migrate this Express.js app to Fastify while maintaining the same API"

sypha "Convert this Python script to TypeScript: @script.py"

sypha "Update the codebase from React 17 to React 18, handling all breaking changes"

sypha "Create Terraform configuration for deploying this app to AWS with EC2, RDS, and S3"

sypha "Create a production-ready Dockerfile and docker-compose.yml for this Node.js + PostgreSQL app"

sypha "Create a GitHub Actions workflow for testing, building, and deploying to AWS"

# Step 1: Plan the architecture
$ /mode plan
> Design a notification system with email, SMS, and push notifications.
> Include queuing, retry logic, and template management.

# Sypha creates detailed plan

# Step 2: Implement core logic
$ /mode code
[Ctrl+Y to enable auto-edit]
> Implement the notification service based on the plan

# Step 3: Add tests
> Generate unit tests for the notification service

# Step 4: Add API endpoints
> Create REST API endpoints for sending notifications

# Step 5: Review all changes
$ /diff --staged

# Step 6: Commit in logical chunks
$ /add src/services/notification/*.ts
$ /commit "Add notification service with email/SMS/push support"

$ /add src/routes/notifications.ts
$ /commit "Add notification API endpoints"

$ /add tests/
$ /commit "Add comprehensive tests for notification system"

# Step 7: Push everything
$ /push

# Project A - Main API
$ cd ~/projects/api
$ sypha "Add rate limiting to all endpoints"
# ... work ...
$ /session save "api-rate-limiting"
$ exit

# Project B - Frontend
$ cd ~/projects/frontend
$ sypha "Update API client to handle rate limit errors"
# ... work ...
$ /session save "frontend-rate-limit-handling"
$ exit

# Project C - Shared Library
$ cd ~/projects/shared-lib
$ sypha "Add rate limit types to shared package"
# ... work ...
$ /session save "shared-lib-rate-limit-types"
$ exit

# Later: Resume any project
$ cd ~/projects/api
$ sypha
$ /session list
$ /session select api-rate-limiting
# Continue where you left off

# Try Claude Sonnet
$ /provider anthropic
$ /model claude-sonnet-4-5
> Implement a binary search tree in TypeScript

# Save the implementation
$ /checkpoint create "claude-bst-implementation"

# Try GPT-4
$ /provider openai
$ /model gpt-4
$ /undo  # Undo Claude's changes
> Implement a binary search tree in TypeScript

# Compare implementations
$ /diff
# Review differences between models' approaches

# Choose the best implementation
# Or cherry-pick features from both

$ /mode debug
> API endpoint /api/orders is returning 500 errors

# Create checkpoint before making changes
$ /checkpoint create "Before debugging orders endpoint"

# Try fix #1: Increase timeout
> Increase the database query timeout to 30 seconds
# Test it... doesn't work

# Restore and try different approach
$ /checkpoint restore <checkpoint-id>

# Try fix #2: Add connection pooling
> Configure database connection pooling
# Test it... still doesn't work

# Restore and try different approach
$ /checkpoint restore <checkpoint-id>

# Try fix #3: Fix N+1 query problem
> Optimize the orders query to use JOIN instead of separate queries
# Test it... works!

# Commit the working fix
$ /commit "Fix N+1 query in orders endpoint"

$ sypha "Add user profile page" &&
  /add src/pages/Profile.tsx &&
  /commit "Add user profile page" &&
  /push

$ sypha "Add tests for auth module"
# After tests are generated
> /checkpoint create "Added auth tests"
> ! npm test
# If tests fail, refine with Sypha
# If tests pass:
> /commit "Add comprehensive auth module tests"

$ sypha "Generate JSDoc for all files in src/services/"
$ /add src/services/
$ /commit "docs: Add JSDoc comments to service layer"

sypha "Make the code better"

sypha "Refactor the authentication module to:
1. Use async/await instead of callbacks
2. Add proper error handling with custom error types
3. Extract validation logic into separate functions
4. Add JSDoc comments"

# Debug based on screenshot
sypha "@error-screenshot.png This error appears when users click the submit button. Why?"

# Implement from design
sypha "@figma-export.png Implement this design in React with Tailwind CSS"

# Understand architecture
sypha "@system-diagram.png Explain this architecture and suggest improvements"

> ! npm test
> ! npm run build
> ! git status
> ! docker-compose up -d

# After completing a major feature
$ /session save "user-authentication-implementation"
$ /session favorite <session-id>

# Add descriptive notes
$ /session rename <session-id> "JWT Auth + OAuth2 + 2FA Implementation"

# Shift+Tab for quick mode switch
[Shift+Tab] → Select "debug"
[Shift+Tab] → Select "plan"
[Shift+Tab] → Select "code"

$ /export session <session-id> --format json
$ /export session <session-id> --format markdown

# Share the exported file with your team
# They can review your conversation and decisions