[!TIP]

Learn more about Agentic Coding!

Automaker itself was built by a group of engineers using AI and agentic coding techniques to build features faster than ever. By leveraging tools like Cursor IDE and Claude Code CLI, the team orchestrated AI agents to implement complex functionality in days instead of weeks.

Learn how: Master these same techniques and workflows in the Agentic Jumpstart course.

Automaker

Stop typing code. Start directing AI agents.

Table of Contents

• What Makes Automaker Different?
• The Workflow
• Powered by Claude Agent SDK
• Why This Matters
• Security Disclaimer
• Community & Support
• Getting Started
• Prerequisites
• Quick Start
• How to Run
• Development Mode
• Interactive TUI Launcher
• Building for Production
• Testing
• Linting
• Environment Configuration
• Authentication Setup
• Features
• Core Workflow
• AI & Planning
• Project Management
• Collaboration & Review
• Developer Tools
• Advanced Features
• Tech Stack
• Frontend
• Backend
• Testing & Quality
• Shared Libraries
• Available Views
• Architecture
• Monorepo Structure
• How It Works
• Key Architectural Patterns
• Security & Isolation
• Data Storage
• Learn More
• License

Automaker is an autonomous AI development studio that transforms how you build software. Instead of manually writing every line of code, you describe features on a Kanban board and watch as AI agents powered by Claude Agent SDK automatically implement them. Built with React, Vite, Electron, and Express, Automaker provides a complete workflow for managing AI agents through a desktop application (or web browser), with features like real-time streaming, git worktree isolation, plan approval, and multi-agent task execution.

What Makes Automaker Different?

Traditional development tools help you write code. Automaker helps you orchestrate AI agents to build entire features autonomously. Think of it as having a team of AI developers working for you—you define what needs to be built, and Automaker handles the implementation.

The Workflow

1. Add Features - Describe features you want built (with text, images, or screenshots)
2. Move to "In Progress" - Automaker automatically assigns an AI agent to implement the feature
3. Watch It Build - See real-time progress as the agent writes code, runs tests, and makes changes
4. Review & Verify - Review the changes, run tests, and approve when ready
5. Ship Faster - Build entire applications in days, not weeks

Powered by Claude Agent SDK

Automaker leverages the Claude Agent SDK to give AI agents full access to your codebase. Agents can read files, write code, execute commands, run tests, and make git commits—all while working in isolated git worktrees to keep your main branch safe. The SDK provides autonomous AI agents that can use tools, make decisions, and complete complex multi-step tasks without constant human intervention.

Why This Matters

The future of software development is agentic coding—where developers become architects directing AI agents rather than manual coders. Automaker puts this future in your hands today, letting you experience what it's like to build software 10x faster with AI agents handling the implementation while you focus on architecture and business logic.

Community & Support

Join the Agentic Jumpstart to connect with other builders exploring agentic coding and autonomous development workflows.

In the Discord, you can:

• 💬 Discuss agentic coding patterns and best practices
• 🧠 Share ideas for AI-driven development workflows
• 🛠️ Get help setting up or extending Automaker
• 🚀 Show off projects built with AI agents
• 🤝 Collaborate with other developers and contributors

👉 Join the Discord: Agentic Jumpstart Discord

---

Getting Started

Prerequisites

• Node.js 22+ (required: >=22.0.0 <23.0.0)
• npm (comes with Node.js)
• Claude Code CLI - Install and authenticate with your Anthropic subscription. Automaker integrates with your authenticated Claude Code CLI to access Claude models.

Quick Start

# 1. Clone the repository
git clone https://github.com/AutoMaker-Org/automaker.git
cd automaker

# 2. Install dependencies
npm install

# 3. Start Automaker
npm run dev
# Choose between:
#   1. Web Application (browser at localhost:3007)
#   2. Desktop Application (Electron - recommended)

Authentication: Automaker integrates with your authenticated Claude Code CLI. Make sure you have installed and authenticated the Claude Code CLI before running Automaker. Your CLI credentials will be detected automatically.

For Development: npm run dev starts the development server with Vite live reload and hot module replacement for fast refresh and instant updates as you make changes.

How to Run

Development Mode

Start Automaker in development mode:

npm run dev

This will prompt you to choose your run mode, or you can specify a mode directly:

Electron Desktop App (Recommended)

# Standard development mode
npm run dev:electron

# With DevTools open automatically
npm run dev:electron:debug

# For WSL (Windows Subsystem for Linux)
npm run dev:electron:wsl

# For WSL with GPU acceleration
npm run dev:electron:wsl:gpu

Web Browser Mode

# Run in web browser (http://localhost:3007)
npm run dev:web

Interactive TUI Launcher (Recommended for New Users)

For a user-friendly interactive menu, use the built-in TUI launcher script:

# Show interactive menu with all launch options
./start-automaker.sh

# Or launch directly without menu
./start-automaker.sh web          # Web browser
./start-automaker.sh electron     # Desktop app
./start-automaker.sh electron-debug  # Desktop + DevTools

# Additional options
./start-automaker.sh --help       # Show all available options
./start-automaker.sh --version    # Show version information
./start-automaker.sh --check-deps # Verify project dependencies
./start-automaker.sh --no-colors  # Disable colored output
./start-automaker.sh --no-history # Don't remember last choice

Features:

• 🎨 Beautiful terminal UI with gradient colors and ASCII art
• ⌨️ Interactive menu (press 1-3 to select, Q to exit)
• 💾 Remembers your last choice
• ✅ Pre-flight checks (validates Node.js, npm, dependencies)
• 📏 Responsive layout (adapts to terminal size)
• ⏱️ 30-second timeout for hands-free selection
• 🌐 Cross-shell compatible (bash/zsh)

History File: Your last selected mode is saved in ~/.automaker_launcher_history for quick re-runs.

Building for Production

Web Application

# Build for web deployment (uses Vite)
npm run build

Desktop Application

# Build for current platform (macOS/Windows/Linux)
npm run build:electron

# Platform-specific builds
npm run build:electron:mac     # macOS (DMG + ZIP, x64 + arm64)
npm run build:electron:win     # Windows (NSIS installer, x64)
npm run build:electron:linux   # Linux (AppImage + DEB + RPM, x64)

# Output directory: apps/ui/release/

Linux Distribution Packages:

• AppImage: Universal format, works on any Linux distribution
• DEB: Ubuntu, Debian, Linux Mint, Pop!_OS
• RPM: Fedora, RHEL, Rocky Linux, AlmaLinux, openSUSE

Installing on Fedora/RHEL:

# Download the RPM package
wget https://github.com/AutoMaker-Org/automaker/releases/latest/download/Automaker-<version>-x86_64.rpm

# Install with dnf (Fedora)
sudo dnf install ./Automaker-<version>-x86_64.rpm

# Or with yum (RHEL/CentOS)
sudo yum localinstall ./Automaker-<version>-x86_64.rpm

Docker Deployment

Docker provides the most secure way to run Automaker by isolating it from your host filesystem.

# Build and run with Docker Compose
docker-compose up -d

# Access UI at http://localhost:3007
# API at http://localhost:3008

# View logs
docker-compose logs -f

# Stop containers
docker-compose down

Authentication

Automaker integrates with your authenticated Claude Code CLI. To use CLI authentication in Docker, mount your Claude CLI config directory (see Claude CLI Authentication below).

Working with Projects (Host Directory Access)

By default, the container is isolated from your host filesystem. To work on projects from your host machine, create a docker-compose.override.yml file (gitignored):

services:
  server:
    volumes:
      # Mount your project directories
      - /path/to/your/project:/projects/your-project

Claude CLI Authentication

Mount your Claude CLI config directory to use your authenticated CLI credentials:

services:
  server:
    volumes:
      # Linux/macOS
      - ~/.claude:/home/automaker/.claude
      # Windows
      - C:/Users/YourName/.claude:/home/automaker/.claude

Note: The Claude CLI config must be writable (do not use :ro flag) as the CLI writes debug files.

⚠️ Important: Linux/WSL Users

The container runs as UID 1001 by default. If your host user has a different UID (common on Linux/WSL where the first user is UID 1000), you must create a .env file to match your host user:

```bash

Check your UID/GID

id -u # outputs your UID (e.g., 1000) id -g # outputs your GID (e.g., 1000) ```

Create a .env file in the automaker directory:

UID=1000 GID=1000

Then rebuild the images:

bash docker compose build

Without this, files written by the container will be inaccessible to your host user.

GitHub CLI Authentication (For Git Push/PR Operations)

To enable git push and GitHub CLI operations inside the container:

services:
  server:
    volumes:
      # Mount GitHub CLI config
      # Linux/macOS
      - ~/.config/gh:/home/automaker/.config/gh
      # Windows
      - 'C:/Users/YourName/AppData/Roaming/GitHub CLI:/home/automaker/.config/gh'

      # Mount git config for user identity (name, email)
      - ~/.gitconfig:/home/automaker/.gitconfig:ro
    environment:
      # GitHub token (required on Windows where tokens are in Credential Manager)
      # Get your token with: gh auth token
      - GH_TOKEN=${GH_TOKEN}

Then add GH_TOKEN to your .env file:

GH_TOKEN=gho_your_github_token_here

Complete docker-compose.override.yml Example

services:
  server:
    volumes:
      # Your projects
      - /path/to/project1:/projects/project1
      - /path/to/project2:/projects/project2

      # Authentication configs
      - ~/.claude:/home/automaker/.claude
      - ~/.config/gh:/home/automaker/.config/gh
      - ~/.gitconfig:/home/automaker/.gitconfig:ro
    environment:
      - GH_TOKEN=${GH_TOKEN}

Architecture Support

The Docker image supports both AMD64 and ARM64 architectures. The GitHub CLI and Claude CLI are automatically downloaded for the correct architecture during build.

Playwright for Automated Testing

The Docker image includes Playwright Chromium pre-installed for AI agent verification tests. When agents implement features in automated testing mode, they use Playwright to verify the implementation works correctly.

No additional setup required - Playwright verification works out of the box.

Optional: Persist browsers for manual updates

By default, Playwright Chromium is pre-installed in the Docker image. If you need to manually update browsers or want to persist browser installations across container restarts (not image rebuilds), you can mount a volume.

Important: When you first add this volume mount to an existing setup, the empty volume will override the pre-installed browsers. You must re-install them:

# After adding the volume mount for the first time
docker exec --user automaker -w /app automaker-server npx playwright install chromium

Add this to your docker-compose.override.yml:

services:
  server:
    volumes:
      - playwright-cache:/home/automaker/.cache/ms-playwright

volumes:
  playwright-cache:
    name: automaker-playwright-cache

Updating browsers manually:

docker exec --user automaker -w /app automaker-server npx playwright install chromium

Testing

End-to-End Tests (Playwright)

npm run test            # Headless E2E tests
npm run test:headed     # Browser visible E2E tests

Unit Tests (Vitest)

npm run test:server              # Server unit tests
npm run test:server:coverage     # Server tests with coverage
npm run test:packages            # All shared package tests
npm run test:all                 # Packages + server tests

Test Configuration

• E2E tests run on ports 30