Stop Coding Manually: Automaker Directs AI Agents to Build Features

Stop Coding Manually: Automaker Directs AI Agents to Build Features

What if you never had to write another line of boilerplate code again?

Picture this: It's 2 AM. Your coffee's gone cold. You've been fighting with a stubborn authentication flow for six hours, and your Jira backlog is laughing at you. Meanwhile, your competitor just shipped three major features. How? They stopped typing code and started directing AI agents.

Here's the uncomfortable truth that top engineers are waking up to: manual coding is becoming a competitive disadvantage. The developers who will dominate the next decade aren't the fastest typists—they're the best architects. The ones who can describe what needs to be built and orchestrate intelligent systems to build it.

Enter Automaker—the autonomous AI development studio that's making traditional coding workflows look like using a horse and buggy in the age of rockets. Built by engineers who practiced what they preach (yes, Automaker itself was built using AI and agentic coding techniques), this isn't another code completion tool. This is a complete paradigm shift.

Stop typing code. Start directing AI agents. Let's dive into why Automaker is the secret weapon that could 10x your development velocity.

What Is Automaker?

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 the Claude Agent SDK automatically implement them.

Created by the AutoMaker-Org team, Automaker represents the bleeding edge of agentic coding—a development paradigm where engineers become architects and directors rather than manual implementers. The tool itself stands as proof of concept: the entire application was built by engineers leveraging AI agents through Cursor IDE and Claude Code CLI, implementing complex functionality in days instead of weeks.

Built with React^{↗ Bright Coding Blog} 19, Vite 7, Electron 39, and Express 5, Automaker provides a complete workflow for managing AI agents through either a desktop application or web browser. Its architecture supports real-time streaming of agent activity, git worktree isolation for safe experimentation, plan approval workflows, and multi-agent task execution.

Why it's trending now: The software industry has reached an inflection point. Large language models have matured from autocomplete toys into genuine reasoning engines. Tools like Claude Code CLI proved AI could navigate complex codebases. Automaker takes that capability and wraps it in a visual, manageable workflow—making agentic coding accessible to teams who don't want to live in terminal windows.

The project currently sits as an open-source MIT-licensed repository, though it's worth noting the maintainers have stated it's no longer actively maintained. However, the codebase remains fully functional and forkable for teams ready to embrace autonomous development.

Key Features That Separate Automaker From the Pack

🎯 Core Workflow Innovation

Automaker's Kanban-driven development isn't project management fluff—it's the control surface for AI orchestration. Features flow through Backlog → In Progress → Waiting Approval → Verified, with each state transition triggering automated behaviors. Move a card to "In Progress," and an AI agent automatically claims it.

🔒 Git Worktree Isolation (The Safety Net You Didn't Know You Needed)

Here's where Automaker gets seriously clever. Every feature executes in an isolated git worktree—a separate checkout of your repository that doesn't touch your main branch. Your AI agent can go wild refactoring, experimenting, even breaking things completely. Your main branch? Pristine. This isn't just version control; it's fearless automation.

📡 Real-Time Streaming Intelligence

Watch your AI agent think in real-time. The WebSocket-powered streaming shows live tool usage, file modifications, command execution, and reasoning steps. You're not submitting a prompt and praying—you're supervising a digital employee.

🧠 Multi-Model, Multi-Mode Planning

Not all features need the same intelligence. Automaker lets you configure:

• Model selection: Claude Opus for complex architecture, Sonnet for balanced tasks, Haiku for quick wins
• Thinking depth: None, medium, deep, or ultra reasoning modes
• Planning intensity: Skip planning for trivial tasks, lite for quick plans, spec for task breakdowns, or full phased execution for mission-critical features

🤝 Multi-Agent Task Execution

In spec mode, Automaker doesn't just use one agent—it spawns dedicated agents per task. Each subtask gets focused, specialized attention rather than a single overwhelmed agent context-switching across concerns.

🐳 Docker^{↗ Bright Coding Blog}-First Security Philosophy

The maintainers are refreshingly honest about AI agent risks: they don't recommend running Automaker directly on your local machine. The Docker deployment provides filesystem isolation, with explicit warnings about the dangers of unconstrained AI file access. This security-first transparency builds trust.

Real-World Use Cases Where Automaker Dominates

1. Rapid Prototyping & MVP Development

Need to validate a feature concept by Friday? Describe it on the board, attach a screenshot or rough wireframe, and let an agent implement a working prototype while you sleep. The git worktree means you can A/B test implementations without branch pollution.

2. Legacy Codebase Modernization

That 50,000-line jQuery monolith isn't going to refactor itself—or will it? Automaker's project analysis understands your structure first, then generates incremental modernization tasks. Agents handle the tedious extraction while you review architectural decisions.

3. Microservice Extraction & API Development

Breaking apart a monolith requires creating dozens of new endpoints, DTOs, and client libraries. Configure dependency blocking so service B's agent waits for service A's contract, then watch parallel implementation unfold with automatic ordering enforcement.

4. Test Infrastructure & DevOps^{↗ Bright Coding Blog} Automation

The built-in Playwright integration means agents don't just write code—they verify it works. Agents can implement features, write corresponding E2E tests, and validate through browser automation. Your CI pipeline just got an AI teammate.

5. Cross-Platform Desktop Application Development

Shipping to macOS, Windows, and Linux simultaneously? Automaker's Electron foundation with platform-specific build pipelines means your AI agents can implement platform-adaptive features while the build system handles distribution packaging (DMG, NSIS, AppImage, DEB, RPM).

Step-by-Step Installation & Setup Guide

Ready to stop typing and start directing? Here's your complete setup path.

Prerequisites

Before touching Automaker, verify your environment:

Critical: The Node.js version constraint is strict. Running on Node 20 or 23 will cause failures.

Quick Start (Development)

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

# 2. Install dependencies
npm install

# 3. Start Automaker with interactive mode selection
npm run dev

At the prompt, choose:

• Option 1: Web Application (browser at localhost:3007)
• Option 2: Desktop Application (Electron—recommended for full features)

Authentication Setup (Non-Negotiable)

Automaker has zero standalone AI credentials. It piggybacks on your authenticated Claude Code CLI:

# Install Claude Code CLI if you haven't
# Follow: https://code.claude.com/docs/en/quickstart

# Authenticate with your Anthropic subscription
claude auth login

# Verify authentication
claude --version

Once authenticated, Automaker auto-detects your CLI credentials. No API keys to manage, no tokens to rotate.

Production-Ready Deployment

Docker (Recommended for Security)

# Clone and enter directory
git clone https://github.com/AutoMaker-Org/automaker.git
cd automaker

# Launch with Docker Compose
docker-compose up -d

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

# Monitor logs
docker-compose logs -f

For project access, create docker-compose.override.yml:

services:
  server:
    volumes:
      # Mount your project directories
      - /path/to/your/project:/projects/your-project
      # Mount Claude CLI credentials (Linux/macOS)
      - ~/.claude:/home/automaker/.claude

Linux/WSL UID fix (critical for file permissions):

# Check your IDs
id -u  # e.g., 1000
id -g  # e.g., 1000

# Create .env file
echo -e "UID=1000\nGID=1000" > .env

# Rebuild with correct permissions
docker compose build

Desktop Build (Native Performance)

# Current platform
npm run build:electron

# Specific platforms
npm run build:electron:mac     # Universal binary (x64 + arm64)
npm run build:electron:win     # NSIS installer
npm run build:electron:linux   # AppImage + DEB + RPM

Output lands in apps/ui/release/.

REAL Code Examples: Automaker in Action

Let's examine actual patterns from the Automaker codebase and workflow.

Example 1: The Core Development Loop

This is the workflow that defines the Automaker experience—no traditional "coding," just feature direction:

# Start the interactive launcher (recommended for newcomers)
./start-automaker.sh

The TUI launcher provides a beautiful terminal interface with gradient colors and ASCII art. Select your mode with keys 1-3, or let the 30-second timeout auto-launch your last choice. Your preference persists in ~/.automaker_launcher_history.

What happens next (no code required from you):

1. The Electron window opens with the Kanban board
2. You press N for new feature, describe: "Add OAuth2 Google login with JWT refresh tokens"
3. Attach architecture diagram screenshot if desired
4. Drag to "In Progress" column
5. AI agent auto-assigns, creates git worktree, begins implementation
6. Watch real-time streaming in the UI as files are read, written, tested

Example 2: Docker Compose Override for Full Integration

For teams needing GitHub operations and multi-project access, here's the complete configuration pattern from the documentation:

# docker-compose.override.yml - Full production setup
services:
  server:
    volumes:
      # Your active projects
      - /path/to/project1:/projects/project1
      - /path/to/project2:/projects/project2
      
      # Claude CLI authentication (required)
      - ~/.claude:/home/automaker/.claude
      
      # GitHub CLI for push/PR operations
      - ~/.config/gh:/home/automaker/.config/gh
      
      # Git identity configuration
      - ~/.gitconfig:/home/automaker/.gitconfig:ro
      
      # Optional: Persist Playwright browsers
      - playwright-cache:/home/automaker/.cache/ms-playwright
    environment:
      # Required on Windows; useful everywhere
      - GH_TOKEN=${GH_TOKEN}

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

Key insight: The :ro (read-only) flag on .gitconfig prevents agents from accidentally rewriting your identity, while the absence of :ro on .claude is intentional—the CLI writes debug logs.

Example 3: Environment Configuration for Secure Team Deployment

# .env file for production-like deployment

# Server configuration
PORT=3008
DATA_DIR=./data
ENABLE_REQUEST_LOGGING=true

# Security boundaries (CRITICAL for multi-user or shared environments)
AUTOMAKER_API_KEY=your-secret-api-key-here
ALLOWED_ROOT_DIRECTORY=/projects
CORS_ORIGIN=https://your-domain.com,https://app.your-domain.com

# Development conveniences (DISABLE in production)
# AUTOMAKER_AUTO_LOGIN=true  # NEVER in production
# OPEN_DEVTOOLS=true         # NEVER in production

The ALLOWED_ROOT_DIRECTORY is your safety rail—agents physically cannot escape this directory even if prompted to. Combined with Docker's filesystem isolation, this creates defense in depth.

Example 4: Project Structure Understanding

Automaker's own monorepo structure reveals how modern agentic tools are architected:

automaker/
├── apps/
│   ├── ui/          # React + Vite + Electron frontend
│   │   ├── src/
│   │   ├── public/
│   │   └── electron/  # Main process, preload scripts
│   └── server/      # Express + WebSocket backend
│       ├── src/
│       └── services/  # Agent, feature, terminal management
└── libs/            # Shared packages (npm workspace)
    ├── types/       # Core TypeScript definitions
    ├── utils/       # Logging, errors, image processing
    ├── prompts/     # AI prompt templates (the secret sauce!)
    ├── platform/    # Path management, security sandboxing
    ├── model-resolver/      # Claude model alias resolution
    ├── dependency-resolver/ # Feature execution ordering
    └── git-utils/   # Worktree creation, branch management

The prompts package is where the magic lives. These templates transform your feature descriptions into structured agent instructions. The platform package enforces path boundaries. Understanding this architecture helps you extend Automaker for custom agent behaviors.

Advanced Usage & Best Practices

🎯 Planning Mode Selection Strategy

Don't default to "full" planning for everything—that's like using a sledgehammer for a thumbtack. Match planning intensity to feature complexity:

🧠 Model Selection Economics

Claude Opus costs significantly more than Haiku. Use Haiku for: code review summaries, simple refactors, documentation generation. Use Opus for: architectural decisions, complex algorithm implementation, security-critical code. Sonnet is your daily driver.

🔀 Dependency Blocking for Complex Features

When features depend on each other, explicitly set dependencies in the UI. This prevents agents from starting work that will immediately conflict, and the Graph view (H shortcut) visualizes these relationships for team communication.

🐳 Docker as Default, Not Fallback

The maintainers' security warning isn't legal boilerplate—it's earned wisdom. AI agents with filesystem access can theoretically be jailbroken into destructive operations. Docker's filesystem isolation isn't paranoia; it's professional practice.

Automaker vs. The Alternatives

The Verdict: Choose Automaker if you need visual workflow management, team coordination, or self-hosted operation. It's the only tool that treats AI agents as managed workers rather than coding assistants. The tradeoff? You're adopting an archived project—fork it, understand it, own it.

Frequently Asked Questions

Is Automaker still maintained?

No—the project is archived. The AutoMaker-Org team explicitly states no bug fixes, security updates, or features are planned. However, the MIT license means you can fork, modify, and maintain your own version. For teams with internal platform engineering capacity, this is actually an advantage: full control, no upstream breaking changes.

How much does it cost to run?

Automaker itself is free (MIT license). Your costs are Anthropic API usage through your Claude Code CLI subscription. Heavy usage of Opus with extended thinking can accumulate costs quickly—monitor with the built-in usage tracking.

Can I use my own AI models (GPT-4, local LLMs)?

Currently, no. The architecture uses the Claude Agent SDK specifically. The "Provider Pattern" in the backend suggests extensibility was considered, but no alternative providers are implemented. Forking to add OpenAI or local model support would require significant backend work.

Is my code safe with AI agents?

Only as safe as your isolation strategy. The git worktree protects your main branch, but the agent can still read your entire repository. The Docker deployment with ALLOWED_ROOT_DIRECTORY restriction is the recommended defense. Never run on production code without review gates.

Can multiple developers use one Automaker instance?

The architecture supports multiple projects but isn't designed for concurrent multi-user collaboration. Each developer should run their own instance, or you should implement API key authentication (AUTOMAKER_API_KEY) with reverse proxy user management.

What happens when agents fail or loop?

Features move to "Waiting Approval" regardless of success—you're always the final gate. Failed agents leave worktree state for inspection. The follow-up instruction feature lets you redirect stuck agents without losing context.

Conclusion: The Future Is Agentic—Are You Ready?

Automaker isn't just a tool; it's a provocation. It asks: what if the act of "coding" as we've known it—fingers on keys, syntax memorized, Stack Overflow tabbed—is a transitional phase in software engineering's evolution?

The evidence is in the tool's own origin story: built by engineers using AI agents to build a tool for directing AI agents. The snake eats its tail, and out comes a rocket.

Yes, the project is archived. Yes, you'll need to invest understanding in its architecture. But the concepts it embodies—git worktree isolation for fearless automation, Kanban-driven agent orchestration, plan approval gates for safety—these are the primitives of tomorrow's development environments.

The teams that master agentic coding now will ship features while competitors are still writing Jira tickets. They'll prototype in hours what takes others weeks. They'll focus on architecture and user value while AI handles implementation detail.

Your move.

👉 Explore the codebase: github.com/AutoMaker-Org/automaker

👉 Join the community: Agentic Jumpstart Discord

👉 Master the techniques: Agentic Jumpstart Course

Stop typing code. Start directing agents. The future of software development is already here—it's just not evenly distributed yet.