Common use cases

    blackbox session
    ```

    > create a todo list web app using React, TypeScript, and Tailwind CSS
    ```

    > add user authentication and data persistence to the todo app
    ```

    ```
    > implement drag-and-drop functionality for reordering tasks
    ```

    ```
    > add dark mode toggle and responsive design
    ```

    > configure the development server and build scripts
    ```

    > create a Node.js Express API for a blog application with user management
    ```

    > add PostgreSQL database integration with Prisma ORM
    ```

    > add JWT authentication and authorization middleware
    ```

    > create CRUD endpoints for posts, comments, and user profiles
    ```

    > my React app crashes when users try to submit the contact form
    ```

    > analyze the contact form component and find the bug
    ```

    > fix the form validation error and add proper error handling
    ```

    > test the contact form to ensure it works correctly now
    ```

    > analyze my React components for performance issues
    ```

    > optimize the user dashboard component to reduce re-renders
    ```

    > refactor the authentication logic into reusable hooks
    ```

    > update the state management to use React Query for server state
    ```

    > review my e-commerce app structure and suggest where to add a wishlist feature
    ```

    > add a wishlist feature with add/remove functionality and persistence
    ```

    > update the product cards to include wishlist buttons
    ```

    > create a wishlist page where users can view and manage saved items
    ```

    > set up Webpack configuration for my React TypeScript project
    ```

    > configure hot reloading and development server with proxy settings
    ```

    > configure Jest and React Testing Library for unit testing
    ```

    > set up ESLint, Prettier, and Husky for code formatting and pre-commit hooks
    ```

    > identify which components and functions need test coverage
    ```

    > create comprehensive unit tests for the user authentication service
    ```

    > write integration tests for the shopping cart functionality
    ```

    > set up Cypress tests for the complete user registration flow
    ```

    > optimize my React app for production deployment
    ```

    > set up deployment to Vercel with environment variables
    ```

    > create GitHub Actions workflow for automated testing and deployment
    ```

    > add error tracking and performance monitoring to the deployed app
    ```

    > design a PostgreSQL schema for a social media application
    ```

    > configure Prisma ORM with PostgreSQL for my Node.js API
    ```

    > implement CRUD operations for users, posts, and comments
    ```

    > create queries for user feed with pagination and filtering
    ```

    > review my jQuery application and plan migration to React
    ```

    > convert the user dashboard from jQuery to React component
    ```

    > migrate CSS styles to Tailwind CSS classes
    ```

    > convert JavaScript functions to TypeScript with proper types
    ```

    > explain the architecture and main components of this React application
    ```

    > explain how the state management works in this Redux setup
    ```

    > walk me through how user authentication is implemented here
    ```

    > suggest modern alternatives to the patterns used in this codebase
    ```

    # Set up a new worktree with a fresh branch
    git worktree add ../my-new-feature -b enhancement-ui

    # Or set up a worktree for an existing branch
    git worktree add ../my-app-fix fix-login-issue
    ```

    This creates a separate folder with an independent copy of your repository.

    # Move to your worktree directory
    cd ../my-new-feature

    # Start Blackbox CLI in this isolated space
    blackbox
    ```

    cd ../my-app-fix
    blackbox
    ```

    # View all active worktrees
    git worktree list

    # Clean up a worktree when finished
    git worktree remove ../my-new-feature
    ```

    # Initialize Git if needed
    git init

    # Or navigate to an existing Git repository
    cd your-project
    ```

    > /multi-agent create a REST API with user authentication, JWT tokens, and CRUD operations for a blog
    ```

    BLACKBOX CLI will automatically:

    * Create separate branches for each agent (Claude, Blackbox, and Codex if OpenAI key is configured)
    * Run all agents in parallel
    * Each agent implements the task independently on its own branch

    # List all branches created
    git branch

    # Check out each branch to review
    git checkout multi-agent-claude-<timestamp>
    git checkout multi-agent-blackbox-<timestamp>
    git checkout multi-agent-codex-<timestamp>
    ```

* Code quality and structure
* Error handling
* Security practices
* Performance considerations
* Documentation and comments

    # Switch to your main branch
    git checkout main

    # Merge the best implementation
    git merge multi-agent-claude-<timestamp>

    # Clean up unused branches
    git branch -D multi-agent-blackbox-<timestamp>
    git branch -D multi-agent-codex-<timestamp>
    git branch -D multi-agent-gemini-<timestamp>
    ```