Async: The Open-Source Developer Tool That Bridges AI Coding with Real-World Workflows

Have you ever felt frustrated when your AI coding assistant makes changes that seem logical in isolation but break your carefully crafted codebase? If you’ve worked with mature projects for more than a few months, you’ve probably experienced this common pain point. Traditional AI coding tools excel at creating new projects from scratch but often stumble when working with established codebases where one wrong move can cascade into multiple failures.

Today, I want to introduce you to a solution that’s changing how developers interact with AI coding assistants: Async. This open-source tool isn’t just another code completion helper—it’s a thoughtfully designed system that combines AI coding capabilities with task management and code review into a single, cohesive workflow. Think of it as bringing together the best aspects of Claude Code, Linear (for project management), and GitHub Pull Requests, but with a workflow specifically engineered for real-world development scenarios.

What Exactly Is Async? Understanding Its Core Purpose

Async is an open-source developer tool that fundamentally reimagines how AI should assist in the software development process. Unlike tools that focus solely on code suggestions as you type, Async takes a step back to understand the entire development workflow—from identifying a problem to merging the final solution.

The key insight behind Async is simple but powerful: in mature codebases, understanding context is more important than generating code quickly. This philosophy shapes every aspect of how Async operates, making it particularly valuable for teams working on established projects where breaking changes can have serious consequences.

The Problem Async Solves: Why Traditional AI Coding Tools Fall Short

Let’s be honest—most AI coding assistants work brilliantly when you’re starting a new project. They can generate boilerplate code, suggest patterns, and even help with documentation. But as your project grows and becomes more complex, these tools often start to struggle. Here’s why:

• They lack deep context awareness: Most AI tools see only the file you’re currently working on, not how it connects to the rest of your system
• They make assumptions without verification: They’ll happily modify code without checking if those changes align with your architectural decisions
• They create monolithic changes: Instead of breaking work into manageable chunks, they often propose large, difficult-to-review pull requests
• They disrupt your workflow: You end up switching between tools and contexts constantly

If you’ve ever had an AI assistant “helpfully” rewrite a critical module in a way that breaks three other features, you understand this frustration all too well.

How Async Works: A Thoughtful Approach to AI-Assisted Development

Async addresses these challenges through a carefully designed workflow that prioritizes safety, clarity, and integration with your existing processes. Let’s walk through how it actually works in practice.

The Research Phase: Asking Questions Before Writing Code

The most distinctive feature of Async is its mandatory research phase. When you assign it a task (typically imported from a GitHub issue), Async doesn’t jump straight into coding. Instead, it:

1. Clones your repository into an isolated Google Cloud Run environment
2. Analyzes your codebase to understand the relevant context
3. Identifies potential modification points and dependencies
4. Generates specific clarifying questions about ambiguous requirements

This step might seem like an extra hurdle at first glance, but it’s actually what makes Async so reliable with mature codebases. By forcing this upfront analysis, Async avoids the common pitfall of AI tools that make incorrect assumptions and then implement them confidently.

Imagine you ask Async to “add user profile pictures to the dashboard.” Instead of immediately generating code that might conflict with your existing authentication system, Async would first ask:

• “Should profile pictures be hosted internally or through a third-party service?”
• “Are there existing image handling utilities we should use?”
• “What size constraints should we apply to uploaded images?”
• “Do we need to consider GDPR compliance for user-uploaded images?”

This questioning approach ensures that when Async does start coding, it’s working with a complete understanding of what needs to be done and how it fits into your existing system.

Execution in Isolation: No More Worried About Broken Local Environments

Another game-changing aspect of Async is where it performs its work. Rather than making changes directly on your local machine (which could potentially break your development environment), Async executes all code modifications in isolated cloud environments.

Here’s what happens behind the scenes:

1. When you approve the research findings, Async schedules an execution job
2. A fresh Google Cloud Run container is spun up with your codebase
3. All modifications happen within this isolated environment
4. You can continue working on other tasks while Async processes your request

This approach offers several important benefits:

• Zero impact on your local setup: Your development environment remains untouched and stable
• Consistent execution environment: Every task runs in a clean, standardized environment
• True asynchronous workflow: You don’t have to wait for AI to finish before moving to your next task

It’s like having a dedicated junior developer who works on your tasks in a separate workspace, then brings you clean, tested solutions ready for review—without ever disrupting your own workflow.

Breaking Work into Reviewable Subtasks: The Power of Stack Diffs

One of the most frustrating aspects of traditional AI coding tools is that they often produce massive pull requests that are difficult to review thoroughly. Async solves this with its innovative approach to task decomposition.

When Async executes a task, it doesn’t generate one giant commit. Instead:

1. It breaks the main task into logical subtasks using Claude Code’s planning capabilities
2. Each subtask gets its own focused commit with a clear purpose
3. These commits form what Async calls “stack diffs”—a series of incremental, reviewable changes

This approach transforms the code review process from overwhelming to manageable. Instead of reviewing 200 lines of scattered changes across multiple files, you can review 5 focused changes of 40 lines each, each with a specific purpose.

For example, if you asked Async to “implement dark mode,” rather than one massive PR, you might get:

1. Subtask 1: Add theme context and state management
2. Subtask 2: Update color variables across the application
3. Subtask 3: Implement user preference storage
4. Subtask 4: Add UI toggle component
5. Subtask 5: Write documentation and tests

Each of these would be a separate, self-contained change that’s easy to understand and verify—making the entire process significantly more reliable.

The Complete Async Workflow: From Issue to Merged PR

Let’s walk through a typical Async workflow from start to finish so you can see how all these pieces fit together in practice.

Step 1: Onboarding and Task Creation

Getting started with Async is straightforward:

1. Install the Async GitHub App and select which repositories you want to integrate
2. Async automatically imports all open GitHub issues as tasks
3. You can view and manage these tasks directly within the Async interface

This seamless integration with GitHub means you don’t have to change your existing issue tracking workflow—Async works with what you’re already using.

Step 2: The Research Phase (Where Async Shines)

When you select a task to work on:

• A Google Cloud Run job is triggered to analyze your codebase
• The research agent examines relevant files and dependencies
• It identifies potential implementation paths and risks
• It generates specific questions about any ambiguous requirements
• The task enters a “waiting for confirmation” state

This is where Async differs most significantly from other tools. Rather than making assumptions, it explicitly seeks clarification on anything unclear—reducing the risk of misinterpretation.

Step 3: Execution Phase

Once you’ve confirmed all details (or if the task is sufficiently clear to proceed automatically):

1. Async creates a new feature branch in your repository
2. It breaks the task into logical subtasks
3. Each subtask is executed as a separate, focused commit
4. After all subtasks are complete, it automatically creates a pull request

The beauty of this approach is that while Async is working through these steps in the cloud, you’re free to continue with other work—truly enabling an asynchronous development workflow.

Step 4: Code Review and Iteration

Async handles the entire review process within its interface:

• You can examine each subtask’s changes individually
• Leave comments directly on specific code lines
• Request changes, which Async will address by creating new subtasks
• Approve changes, which Async will then squash and merge

This integrated approach eliminates the need to switch between GitHub, Slack, and email during the review process, making collaboration significantly smoother.

Under the Hood: Async’s Technical Architecture

Understanding Async’s technical foundation helps appreciate why it works so effectively. Let’s explore the key components that power this tool.

Core Technology Stack

Async leverages a thoughtful combination of modern technologies to deliver its unique capabilities:

Component	Technology	Purpose
Backend	FastAPI with async support	Handles API requests and business logic efficiently
AI Models	Claude Code for implementation, multiple models for research	Provides the coding intelligence with specialized roles
Cloud Platform	Google Cloud Platform	Offers isolated, scalable execution environments
Database	Firebase Firestore	Stores task data, user information, and project metadata
Frontend	Responsive design	Works across desktop and mobile devices

This stack was carefully chosen to balance performance, reliability, and developer experience.

Google Cloud Run Job Types

Async uses four primary job types to handle different aspects of the development workflow, each running in its own isolated container:

Job Type	Function	Execution Process
execute-task	Main task implementation	1. Clones to feature branch 2. Breaks task into subtasks 3. Executes each as separate commits 4. Creates pull request
research-task	Codebase analysis and requirement gathering	1. Analyzes project structure 2. Identifies relevant context 3. Generates clarifying questions 4. Creates task summary
revise-task	Handling review feedback	1. Processes comments 2. Creates new subtask for changes 3. Re-executes with updates
index-project	Project setup and indexing	1. Analyzes project structure 2. Sets up metadata 3. Prepares for AI analysis

Each job runs in complete isolation, ensuring that one task’s execution never interferes with another—a critical feature for reliability when working with multiple concurrent tasks.

Setting Up Async: A Practical Guide

Let’s walk through how to get Async running in your development environment. The setup process is designed to be straightforward while ensuring all dependencies are properly configured.

Prerequisites

Before installing Async, make sure you have these basic tools:

• Python 3.10 or newer
• uv (a fast Python package installer and resolver)
• pre-commit (for managing Git hooks)
• gcloud SDK (for Google Cloud integration)

Creating Your Development Environment

The first step is to set up a clean virtual environment:

# Create and activate a virtual environment
uv venv .venv
source .venv/bin/activate

This creates an isolated environment for Async, preventing conflicts with other Python projects you might have.

Installing Dependencies

With your virtual environment active, install Async’s dependencies:

# Sync the environment with required packages
uv sync

This command installs all the necessary packages specified in Async’s configuration.

Configuring Pre-Commit Hooks

Async uses pre-commit hooks to maintain code quality standards:

# Set up pre-commit hooks
pre-commit install

These hooks will automatically check your code for common issues before you commit changes, helping maintain consistency.

Environment Configuration

Async requires some configuration files to connect with your services:

1. Create a .env file in the project root (you can use .env.local as a template)
2. Create a async-firebase.json file with your Firebase configuration
3. Authenticate with Google Cloud:

   gcloud auth application-default login
   

This authentication step allows Async to interact with Google Cloud services needed for its isolated execution environments.

Starting the Development Server

Once everything is configured, you can launch Async:

uvicorn src.server:app --reload --port 8000

This starts the Async server with automatic reloading (helpful during development) on port 8000. You can now access the interface at http://localhost:8000.

Maintaining Code Quality

Async includes tools to help keep your code clean:

# Format code according to project standards
uv run ruff format .

# Check for issues and automatically fix what's possible
uv run ruff check . --fix

These commands ensure your contributions follow the project’s coding conventions.

Running Tests

Before making changes to Async itself, it’s important to verify everything works:

python -m pytest

This runs all unit tests to confirm the system functions as expected.

API Documentation: Understanding Async’s Integration Points

Async provides a comprehensive API that enables its various features and integrations. Understanding these endpoints helps when troubleshooting or extending Async’s capabilities.

Authentication Endpoints

Async handles user authentication through several key endpoints:

• POST /auth/auth-with-github: Completes the GitHub OAuth flow using an access code
• POST /auth/verify-email: Sends an email verification code to new users
• POST /auth/redeem-email-code: Validates the email verification code
• POST /auth/invite-people: Allows team members to send invitations to others
• POST /auth/redeem-invite-code: Validates invitation codes for new users

These endpoints create a secure authentication flow that integrates seamlessly with GitHub, which many development teams already use.

GitHub Integration Endpoints

The connection between Async and GitHub is critical to its functionality:

• POST /github/handle-github-events: Processes webhook events from GitHub (issues, PRs, pushes)
• POST /github/submit-review: Submits code review decisions (approve or request changes)

These endpoints enable Async to stay synchronized with your GitHub repositories, automatically importing issues and updating pull requests.

Task Management Endpoints

The core functionality of Async revolves around task processing:

• POST /task/schedule-job: Schedules various types of task execution jobs (research, execute, revise, index)
• WebSocket /task/chat: Provides real-time communication with AI agents during task execution

These endpoints power the asynchronous workflow that gives Async its name, allowing tasks to be processed in the background while you continue working.

Payment System Endpoints

For teams using Async’s hosted service:

• POST /payment/create-checkout-session: Creates a Stripe checkout session for subscriptions
• POST /payment/create-portal-session: Provides access to the customer billing portal
• POST /payment/handle-stripe-events: Processes Stripe webhook events

These endpoints handle the business aspects of Async’s hosted service while keeping the open-source core completely free.

Deploying Async to Production

If you’re ready to use Async with your team, here’s what you need to know about deploying it to a production environment.

Prerequisites for Production Deployment

Before deploying Async, ensure you have:

• A Google Cloud Platform account with Cloud Run enabled
• A Firebase project with Firestore database configured
• A GitHub App properly configured for your organization
• A Stripe account if you plan to use the payment features

These services form the backbone of Async’s functionality, providing the necessary infrastructure for its operations.

Essential Environment Variables

For Async to function properly in production, you’ll need to configure these critical environment variables:

ANTHROPIC_API_KEY=your_anthropic_api_key
OPENAI_API_KEY=your_openai_api_key
GOOGLE_API_KEY=your_google_api_key
STRIPE_SECRET_KEY=your_stripe_secret_key
GITHUB_WEBHOOK_SECRET=your_github_webhook_secret
DB_URI=your_database_connection_string

Each of these connects Async to the external services it relies on, from AI models to payment processing.

Deployment Process

Async is designed to run on Google Cloud Run, which provides several advantages:

1. Automatic scaling based on demand
2. Isolated execution environments for each task
3. Built-in security and networking features
4. Simple deployment process

The deployment itself involves:

• Configuring your Cloud Run service with the necessary environment variables
• Setting up the GitHub App webhook to point to your Cloud Run service
• Verifying Firebase and Stripe integrations

This architecture ensures that Async can handle multiple concurrent tasks safely and efficiently, without resource conflicts.

Contributing to Async: Joining the Open-Source Community

Async is an open-source project, and contributions from the community are welcome. Here’s how you can get involved:

Getting Started with Contributions

1. Fork the Async repository on GitHub
2. Create a new feature branch: git checkout -b feature/your-amazing-feature
3. Make your changes following the project’s coding standards
4. Run all tests and linting checks
5. Commit your changes with a clear message: git commit -m 'Add your amazing feature'
6. Push your branch: git push origin feature/your-amazing-feature
7. Open a Pull Request against the main repository

Quality Standards

To ensure contributions maintain Async’s high quality:

• Code should follow the existing style conventions
• New features should include appropriate tests
• Documentation should be updated where necessary
• Changes should pass all existing tests

The project maintainers will review your contribution, provide feedback if needed, and work with you to get it merged.

Frequently Asked Questions

Let’s address some common questions developers have about Async.

How is Async different from GitHub Copilot?

While GitHub Copilot focuses on real-time code suggestions as you type, Async handles the entire development workflow from issue to merged PR. Copilot is like a helpful pair programmer sitting next to you, while Async is more like a dedicated team member who takes on specific tasks, does the research, implements the solution, and presents it for review—all while you focus on other work.

How does Async ensure it won’t break my existing code?

Async employs a three-layer safety approach:

1. Research phase: It analyzes your codebase and asks clarifying questions before making any changes
2. Isolated execution: All modifications happen in cloud containers, never touching your local environment
3. Subtask decomposition: It breaks work into small, reviewable units rather than making massive changes

This multi-layered approach significantly reduces the risk of unexpected breakages.

Do I need to change my existing development workflow to use Async?

Not at all. Async is designed to integrate with your current GitHub-based workflow. It automatically imports GitHub issues, creates pull requests on GitHub, and works within your existing review processes. You can continue using the tools and practices you’re already comfortable with—Async simply enhances them with AI capabilities.

Which programming languages does Async support?

Async analyzes your codebase to determine which languages you’re using. As long as the AI models it uses (primarily Claude Code) support your language—which covers most mainstream programming languages—Async can work with your project. The system is language-agnostic in its approach, focusing on understanding your specific code patterns and conventions.

How long does a typical task take to complete?

Task duration varies based on complexity:

• Simple tasks (like bug fixes): 5-15 minutes
• Medium complexity (feature additions): 15-30 minutes
• Complex tasks (architectural changes): 30+ minutes

Remember that while Async is processing your task, you’re free to work on other things—this asynchronous nature is part of what makes it so efficient.

Is my code safe with Async?

Yes, with several important safeguards:

• Code is only accessed from repositories you explicitly authorize
• All processing happens in isolated environments
• Only necessary code (relevant to the task) is analyzed
• You maintain complete control over which repositories are integrated

Async is designed with security and privacy as top priorities, recognizing that your code is your most valuable asset.

Can Async replace human developers?

Absolutely not—and that’s not its goal. Async is designed to augment human developers by handling well-defined, repetitive tasks, allowing you to focus on higher-level design, complex problem-solving, and creative aspects of development. It’s a tool to enhance productivity, not replace expertise.

Who Should Consider Using Async?

Async isn’t for everyone, but it’s particularly valuable for:

• Teams with established codebases: Projects that have been active for 6+ months with stable architecture
• Organizations with strong code review practices: Teams that value thorough review processes
• Distributed teams: Groups working across time zones who benefit from asynchronous workflows
• Developers seeking focus: Those who want to minimize context switching between tasks

If you find yourself frequently frustrated by AI tools that “almost” get it right but introduce subtle errors in complex systems, Async’s careful, methodical approach might be exactly what you need.

Why the “Ask First, Code Later” Approach Works

The most distinctive aspect of Async—its insistence on research and clarification before coding—isn’t just a safety measure; it’s based on a fundamental insight about software development: understanding the problem is often harder than implementing the solution.

Traditional AI tools often skip this crucial understanding phase, jumping straight to implementation. But in real-world development, especially with mature systems, the context matters immensely. A change that makes perfect sense in isolation might violate architectural constraints or create unexpected interactions elsewhere.

By building in this research phase, Async aligns with how experienced developers actually work—they investigate, plan, and clarify before writing significant code. This approach might seem slower at first glance, but it prevents the much more time-consuming process of debugging and fixing AI-generated errors that don’t fit your system’s context.

The Future of Async

As an open-source project, Async’s development is guided by real user needs rather than hype cycles. Current community efforts are focusing on:

• More sophisticated codebase analysis capabilities
• A plugin architecture to support additional AI models
• Deeper integrations with other project management tools
• Enhanced test generation and validation

What’s notable is the project’s commitment to solving actual developer pain points rather than chasing the latest AI trends. This focus on practical value over novelty is what makes Async stand out in a crowded field of developer tools.

Conclusion: Embracing Thoughtful AI Assistance

Async represents an important evolution in how we integrate AI into the software development process. Rather than trying to replace developers or prioritize speed above all else, it acknowledges the complexity of real-world codebases and designs its workflow accordingly.

The most valuable AI tools aren’t those that generate the most code the fastest—they’re the ones that understand context, respect existing systems, and integrate smoothly into established workflows. Async embodies this philosophy, offering a balanced approach that enhances developer productivity without compromising on code quality or safety.

If you’re working with a codebase that’s beyond the “hello world” stage and finding that traditional AI coding tools create more problems than they solve, Async deserves a closer look. It might just transform how you and your team approach development tasks—making AI assistance not just powerful, but truly reliable.

---

Async is an open-source project licensed under the MIT License. You can find the source code on GitHub and learn more about the hosted service at async.build.