Automaker: AI-Powered Autonomous Development Studio

Automaker is an autonomous AI development studio that reimagines how software is built by letting machines do the heavy lifting. Rather than laboring through line-by-line code, you describe the features you want on a Kanban board, and AI agents powered by the Claude Agent SDK work in concert to implement those features. The system is engineered to orchestrate intelligence across multiple agents, manage isolated work environments, and provide real-time visibility into progress, tests, and changes. The overall experience is grounded in a modern tech stack—built with React for the user interface, Vite as the build tool, Electron to deliver a desktop experience, and Express as the backend—yet the core value sits in the way it couples feature planning with autonomous implementation. Visually, Automaker presents an inviting, gradient-rich desktop/web application that puts AI-assisted software production within reach for teams and individuals who want speed without sacrificing structure.

Image: Automaker Logo. This image captures the branding of Automaker, a compact emblem that hints at speed, precision, and the fusion of engineering prowess with modern AI tooling. The logo’s design sits at the crossroads of industry and innovation, signaling a product that aims to elevate how developers think about building software by leveraging intelligent agents.

Image: Automaker UI. The screenshot depicts a polished user interface where teams manage features through a Kanban-style board, see real-time agent activity, and interact with a rich set of panels that track context, specifications, and execution state. The UI image communicates Automaker’s emphasis on clarity, live feedback, and an integrated workflow that blends planning, execution, and review in a single environment.

What makes Automaker different is not simply the automation of routine coding tasks but the orchestration of an AI-powered development team. Traditional development tools help you write code; Automaker helps you direct and synchronize a cohort of AI agents that implement entire features autonomously. Think of it as having a specialist team of AI developers that you guide with prompts, constraints, and project structure, while the actual implementation—writing, testing, and integrating code—happens under the hood in a controlled, auditable manner.

The workflow is designed to be intuitive yet powerful. First, you Add Features to a Kanban board, describing them with text, images, or screenshots. When you move a feature card to In Progress, Automaker automatically assigns an AI agent to take ownership and begin work. Progress unfolds in real time as the agent writes code, runs tests, and adapts based on feedback. When everything looks good, you Review & Verify the changes, run the suite of tests, and approve the implementation. Finally, Ship Faster — complete, tested features can be released, enabling you to assemble entire applications in days rather than weeks.

At the heart of Automaker’s capability is the Claude Agent SDK. This software development kit gives AI agents broad access to your codebase while preserving discipline through isolated git worktrees. Agents can read and modify files, execute commands, run tests, and commit changes, all while operating within sandboxed worktrees that protect your main branch from disruption. The Claude Agent SDK enables agents to use tools, make decisions, and carry out multi-step tasks without requiring constant human intervention. In practical terms, this means you can describe a feature, watch as one or more agents strategize, test, and implement, and then review the resulting code with a sense of architectural overview rather than microscopic coding details.

Why this matters becomes clearer when you consider the broader trend toward agentic coding. The future of software development is not about developers typing furiously, but about architects directing AI agents to execute complex plans. Automaker makes that future tangible today by delivering a system where agents handle implementation while you concentrate on high-level design, system architecture, and business logic. The result is not merely faster coding; it’s a shift in cognitive load, enabling teams to experiment, iterate, and refine at pace.

Community and support are an important part of Automaker’s ecosystem. The project champions participation in the Agentic Jumpstart community, a place where builders explore agentic coding and autonomous development workflows. The Discord channel hosts discussions on patterns, best practices, setup assistance, and project showcases. It’s a space for collaboration, troubleshooting, and sharing ideas that push the boundaries of what AI-assisted development can achieve.

Getting started with Automaker is straightforward, but it does require a few prerequisites. You’ll need Node.js 22 or newer (but below 23.0.0), npm (which comes with Node.js), the Claude Code CLI, and an Anthropic subscription authenticated for Claude Code usage. Automaker is designed to integrate with your Claude Code CLI credentials so that the AI agents can access Claude models securely and efficiently. The quick start narrative in the documentation suggests these practical steps: clone the repository, install dependencies, and start the development server. You can opt for a web browser interface or the Electron-based desktop application, depending on your preferred workflow. The development mode brings hot module replacement and live reload, so changes are visible almost instantly as you work.

In development mode, Automaker supports multiple run modes, with the Electron desktop app strongly recommended for its integrated experience. There are commands for starting in electron mode, enabling DevTools, and running in WSL environments with GPU acceleration when needed. If you’d rather work in a browser, there is a web mode that runs at localhost:3007. For new users who want a guided start, Automaker provides an Interactive TUI Launcher, a terminal-based menu that shows launch options, remembers your last choice, and provides quick access to the web or desktop experiences. Quick-start commands also explain how to activate authentication by ensuring Claude Code CLI credentials are present so that Automaker can automatically detect and use them.

Automaker is feature-rich in its core workflow. The Kanban board is the primary hub for managing feature lifecycles, moving work through stages such as backlog, in progress, waiting approval, and verified. AI agent integration is automatic: when a feature enters In Progress, an agent is assigned to implement it. The system emphasizes git worktree isolation, ensuring that each feature’s development occurs in an isolated environment that won’t disrupt the main codebase. Real-time streaming brings the agent’s tool usage, progress updates, and task completions to the frontend as they happen, enabling project stakeholders to observe the evolution of the feature without waiting for post hoc reports. Follow-up instructions can be issued to running agents without interrupting their ongoing work, increasing responsiveness and adaptability.

The AI & planning capabilities extend Automaker’s usefulness beyond simple automation. Multi-model support lets you choose among Claude Opus, Sonnet, and Haiku for different features, leveraging the strengths of various models as needed. Thinking modes—none, medium, deep, ultra—allow you to tune the depth of reasoning for complex problems. Planning modes define how features are broken down and executed: skip (direct implementation), lite (quick plan), spec (task breakdown), and full (phased execution). Plan approval gives human oversight over AI-generated plans before implementation begins. In spec mode, the system can spawn dedicated agents per task within a feature, allowing fine-grained and parallelized work that accelerates delivery.

Project management within Automaker includes AI-powered project analysis to understand the project structure and potential improvement opportunities. It can propose feature suggestions based on the analysis, manage context files (markdown documents and images) that agents reference automatically, and enforce execution order through dependency blocking. A graph view provides interactive visualization of feature dependencies, helping teams reason about relationships and impacts. GitHub integration enables importing issues, validating feasibility, and converting them into tasks, ensuring alignment with existing project management tools and workflows.

Collaboration and review are central to maintaining quality and alignment with business goals. A verification workflow moves features into a waiting approval state for review and testing. The agent chat capability provides interactive sessions with AI agents for exploratory work and clarification. AI profiles let you tailor agent configurations with different prompts, models, and settings to suit specific tasks or teams. Session history persists across restarts, offering full conversation transcripts for auditability and knowledge reuse. A built-in Git diff viewer lets you review changes made by agents before approving them, keeping human oversight explicit and accessible.

On the developer tooling side, Automaker offers an integrated terminal with tabbed and persistent sessions, along with support for attaching screenshots and diagrams to feature descriptions to maintain clear visual context. Concurrent execution settings let you control how many features can run simultaneously by default (three) and provide keyboard shortcuts for rapid navigation and actions. A theme system with more than 25 themes, including popular options like Dark, Light, Dracula, Nord, and Catppuccin, helps teams tailor the look and feel to their preferences. The platform is cross-platform, with a desktop app for macOS (x64 and arm64), Windows (x64), and Linux (x64), and a web mode that runs in a browser.

Advanced features elevate Automaker beyond a simple automation tool. Docker isolation is highlighted as a security-centric deployment model that minimizes host filesystem exposure. Worktree management supports creating, switching, committing, and generating PRs directly from worktrees, making it easier to manage changes across multiple features. Usage tracking provides visibility into Claude API usage with detailed metrics, helping teams monitor costs and performance. Audio notifications offer optional completion sounds, and an auto-save feature ensures that all work is persisted to the .automaker directory automatically.

The tech stack is comprehensive and designed to support a robust, scalable development environment. The frontend relies on React 19, Vite 7 for the build and dev server, Electron 39 for a native-like desktop experience, TypeScript 5.9 for type safety, TanStack Router for routing, Zustand for state management with persistence, Tailwind CSS 4 for styling, Radix UI primitives for accessibility, dnd-kit for drag-and-drop interactions, and a collection of specialized libraries for graph visualization, terminal emulation, code editing, and iconography. The backend sits on Node.js with Express 5, TypeScript 5.9, and the Claude Agent SDK, with WebSocket support for real-time streaming and node-pty for PTY terminal sessions.

Testing and quality assurance in Automaker are supported by Playwright for end-to-end tests and Vitest for unit tests, with ESLint, Prettier, and Husky for linting and pre-commit hooks. Shared libraries provide reusable building blocks across the monorepo: a types package for shared TypeScript definitions, a utils package for logging and error handling, a prompts library for AI prompt templates, a platform package for path management and security, a model-resolver for Claude model aliasing, a dependency-resolver for feature ordering, and a git-utils package for Git operations and worktree management.

Automaker defines a curated set of available views to support different workflows and user needs. The Board view is the default Kanban board (keyboard shortcut K), Agent view enables interactive agent chats (A), Spec view helps with project specification (D), Context view manages context files (C), Settings for configuration and preferences (S), Terminal for shell access (T), Graph for dependency visualization (H), Ideation for brainstorming (I), Memory for persistent agent memory (Y), GitHub Issues and GitHub PRs provide import and management capabilities (G, R), and a Running Agents view aggregates active agents across projects. Keyboard navigation is designed to be efficient and customizable, with quick access to these views and actions.

From an architectural perspective, Automaker is organized as a monorepo with a clear separation between the UI and server, and a suite of shared libraries that encapsulate core capabilities. The monorepo structure looks like a spiderweb of related packages and apps, all coordinated to support a cohesive experience. The architecture emphasizes event-driven design, enabling server-side operations to stream events to the frontend in real time. The provider pattern is central to extensibility; Automaker currently centers Claude as the AI provider but is designed to accommodate future AI providers with a similar integration point. Service-oriented backend structure, persistent frontend state via Zustand, and a file-based storage model together create a lightweight yet resilient foundation that avoids a traditional database system in favor of a transparent, human-readable storage layout.

Security and isolation are recurring priorities. The use of git worktrees ensures that each feature’s development occurs in an isolated environment, reducing the risk to the main codebase. Path sandboxing and an optional ALLOWEDROOTDIRECTORY setting help restrict file access, and Docker isolation is recommended for production deployments to avoid host filesystem exposure. There is a cautious stance regarding security: a prominent security disclaimer warns that AI-powered tooling can read, modify, and delete files, and advises sandboxing Automaker with Docker or a virtual machine for safety. The project explicitly notes that it is not actively maintained, meaning users must review code and updates themselves, and community contributions may be accepted without guarantees of review.

Data storage in Automaker is designed to be transparent and accessible to developers. Per-project data is stored under a .automaker directory inside each project, containing features, context, worktrees, plan data, images, and other metadata. For example, a typical per-project data structure includes feature JSON files, agent-output logs, and images, organized by feature. There is also a set of global data stored under a DATA_DIR (default ./data), including global settings, credentials, and agent session histories. This approach provides a straightforward, file-based approach to persistence that aligns with the monorepo’s tooling and testing strategies.

The documentation includes a thorough security disclaimer and a cautionary note about the risks of running AI-powered tooling that can access the operating system. It reinforces best practices: sandbox the application, review the code, and proceed with care when deploying to production, especially in environments where sensitive data or critical systems are involved. The license for Automaker is MIT, making it accessible for study, fork, and adaptation, provided users comply with the license terms. The license note sits within a broader project status statement that indicates the project is no longer actively maintained but remains available as a resource for learning, experimentation, or inspiration for those who wish to use or fork it.

Learn more is a natural destination for readers who want deeper engagement. The documentation suite includes a Contributing Guide that explains how to contribute to Automaker, project documentation with architecture guides and developer docs, a guide to shared packages, and instructions for using monorepo packages. Community resources point to the Agentic Jumpstart Discord, inviting developers to participate in a broader conversation about agentic coding and autonomous development workflows. These resources are designed to support a learning trajectory for individuals and teams who want to explore AI-driven software production at scale.

In summary, Automaker presents a bold vision for software development where human architects define what should be built, and AI agents—powered by Claude Agent SDK—translate those definitions into working features with minimal manual coding. It combines a Kanban-based workflow, real-time visibility, workspace isolation through git worktrees, and a rich feature set that covers planning, collaboration, testing, deployment, and governance. Its tech stack spans frontend and backend technologies designed for speed, reliability, and extensibility, while its data storage and security model reflects a pragmatic balance between transparency and protection. The project’s vantage point is both inspirational and instructive: it demonstrates how agentic coding can accelerate delivery, how to structure AI-driven workflows for reliability, and how to orchestrate multiple models and tools to achieve coherent, auditable outcomes.

Even though Automaker is no longer actively maintained, its design offers valuable insights for teams interested in AI-assisted development. The combination of a structured Kanban workflow with autonomous agents, coupled with a robust set of developer tools, provides a framework for exploring new ways of working with AI—whether you’re prototyping ideas, teaching automation concepts, or building the next generation of AI-enabled development environments. The included images—one of the Automaker logo and another of the Automaker user interface—highlight how branding and visual design align with the software’s ambitious capabilities, presenting a product that promises speed, clarity, and collaborative intelligence in software construction.