# Creating API keys
Source: https://docs.delino.io/core/api-keys/creation
Learn how to create API keys to securely access and integrate with our platform.
API keys allow you to securely authenticate and integrate with the Delino platform programmatically.
## Prerequisites
* Active Delino account
* Appropriate permissions to create API keys in your team
## Creating a new API key
1. Navigate to the API Keys page by clicking **API Keys** in the left sidebar
2. Click the **New Key** button in the top-right corner
3. Configure your API key settings:
* Enter a descriptive name for the key
4. Click **Create** to generate the key
Copy and store your API key immediately after creation. For security reasons, you won't be able to view the full key again.
## Managing your API keys
You can view and manage all your API keys at:
* Personal account: [https://app.delino.io/en/teams/\~/api-keys](https://app.delino.io/en/teams/~/api-keys)
From this page, you can:
* View all active API keys
* Revoke keys that are no longer needed
## Best practices
* Use descriptive names that indicate the key's purpose
* Create separate keys for different applications or environments
* Revoke unused or compromised keys immediately
* Never share keys in public repositories or client-side code
# Managing API Keys
Source: https://docs.delino.io/core/api-keys/management
Learn how to view, rotate, and revoke your API keys.
Proper API key management is essential for maintaining security and access control. This guide covers viewing, monitoring, and revoking your API keys.
## Viewing API Keys
Navigate to the API Keys page for your account:
* **Personal Account**: `/teams/~/api-keys`
* **Team Account**: `/teams/[team-slug]/api-keys`
### Key Information Displayed
Each API key shows the following information:
The display name you chose when creating the key
Masked token value (e.g., `deli_****...****abcd`)
The full token is only shown once at creation time
Summary of scopes assigned to the key:
* "Full Access" for `["*"]`
* "X services" for service-level access
* "X scopes" for granular permissions
Click to view detailed scope list
When the key was created
When the key was last used
Helps identify unused keys for cleanup
Expiration date (or "Never" if no expiration)
## Monitoring Usage
### Last Used Timestamp
The "Last Used" column updates whenever the API key successfully authenticates a request. This helps you:
* **Identify Active Keys**: See which keys are actively in use
* **Detect Unused Keys**: Find keys that haven't been used recently
* **Security Auditing**: Track key usage patterns
* **Cleanup Planning**: Identify candidates for revocation
Review the "Last Used" column monthly to identify and remove unused keys.
### Permission Details
Click on any key's permission summary to view the complete list of scopes:
```
Full Access
├── * (all services and operations)
2 services
├── service-a:*
└── service-b:*
3 scopes
├── service:resource:read
├── service:resource:write
└── appcore:payment:update
```
## Revoking API Keys
Revoking an API key is **permanent and immediate**. Any applications using the key will lose access immediately.
### How to Revoke
1. Navigate to the API Keys page
2. Find the key you want to revoke
3. Click the **Delete** button (trash icon)
4. Confirm the deletion
The key is immediately revoked and can no longer be used for authentication.
### When to Revoke
Revoke keys in these situations:
If a key has been exposed or leaked:
1. Immediately revoke the compromised key
2. Create a new key with the same permissions
3. Update your applications with the new key
4. Review recent usage for suspicious activity
If a key hasn't been used in a long time:
1. Verify the key is truly unused
2. Check with your team if it's a team key
3. Revoke the key to reduce attack surface
When a project or service is retired:
1. Document which keys were used
2. Revoke all associated keys
3. Remove keys from any documentation
When a team member leaves:
1. Review keys created by the member
2. Revoke personal keys if applicable
3. Rotate shared keys they had access to
As part of security best practices:
1. Create new keys with same permissions
2. Update applications with new keys
3. Revoke old keys after verification
4. Document rotation date
## Key Rotation
Key rotation is a security best practice that involves regularly replacing API keys.
### Rotation Process
Generate a new API key with the same scopes as the old key
```bash theme={null}
Name: "Production - Image Processing v2"
Scopes: Same as old key
Expiration: 1 year (or same as old key)
```
Update your applications to use the new key
```bash theme={null}
# Example: Update environment variable
export DELINO_API_KEY="deli_new_key_value"
# Restart services
systemctl restart myapp
```
Verify the new key works correctly
```bash theme={null}
# Test API call with new key
curl -H "Authorization: Bearer deli_new_key_value" \
https://api.delino.io/...
```
Wait 24-48 hours and monitor "Last Used" timestamp
If old key is still being used:
* Identify which service is using it
* Update that service
* Wait and verify again
Once confirmed the old key is no longer used:
1. Revoke the old key
2. Monitor for any errors
3. Document the rotation
### Rotation Schedule
Recommended rotation frequencies:
| Environment | Frequency | Reason |
| ----------- | ----------- | --------------------------------------- |
| Development | 30-90 days | Frequent changes, lower risk |
| Staging | 60-180 days | Balance of security and stability |
| Production | 90-365 days | Stability critical, planned rotations |
| CI/CD | 60-180 days | Automated environments easier to update |
These are recommendations. Adjust based on your organization's security policies.
## Troubleshooting
### Key Not Working
If an API key stops working:
1. **Check Expiration**: Verify the key hasn't expired
2. **Verify Scopes**: Ensure the key has required permissions
3. **Test Authentication**: Try a simple API call
4. **Check Last Used**: See if it's being used at all
5. **Review Logs**: Check application logs for error messages
### Permission Denied
If you get permission errors:
1. **Review Scopes**: Check the key's scope list
2. **Verify Endpoint**: Ensure the endpoint matches a scope
3. **Check Wildcards**: Understand wildcard coverage
4. **Contact Support**: If scope seems correct but fails
### Cannot Delete Key
If you cannot delete a key:
1. **Check Permissions**: Ensure you have admin rights
2. **Verify Ownership**: Confirm the key belongs to your account
3. **Try Again**: Temporary network issues may occur
## Best Practices Summary
Review API keys monthly for unused or expired keys
Use names that identify purpose and version (e.g., "Production v2")
Track "Last Used" to identify active and inactive keys
Implement key rotation based on environment risk level
Maintain internal documentation of key purposes
Remove unused keys immediately to reduce attack surface
## Next Steps
Complete list of available API key scopes
# API Keys Overview
Source: https://docs.delino.io/core/api-keys/overview
Understand how API keys work and how to use them for programmatic access to Delino services.
API keys (Personal Access Tokens) allow you to authenticate API requests without using your main account credentials. They provide secure, programmatic access to Delino services with fine-grained permission control.
## How API Keys Work
API keys are Personal Access Tokens (PATs) that provide a secure way to authenticate API requests. Each key has:
* **Unique Token**: A secure token value shown only once at creation
* **Display Name**: A user-friendly name you choose
* **Scopes**: Fine-grained permissions controlling what the key can access
* **Expiration**: Optional expiration date
## Permission Scopes
API keys use a scope-based permission system with the format: `service:resource:action`
### Scope Levels
Grant complete access to all services and operations.
**Scope**: `["*"]`
**Use case**: Development and testing environments
Grant access to all operations within specific services.
**Example**: `service:*` - All operations for a specific service
**Use case**: Production applications using specific services
Grant access to specific operations within services.
**Examples**:
* `service:resource:action` - Specific operation only
* `appcore:payment:update` - Access billing portal only
**Use case**: Maximum security with minimal permissions
### Wildcard Support
Scopes support wildcards for flexible permission management:
* `*` - Full access to everything
* `service:*` - All operations in a service
* `service:resource:*` - All actions on a resource
### Available Scopes
**AppCore**:
* `appcore:payment:update` - Access billing portal URL
* `appcore:team:read` - Read team information
* `appcore:team:write` - Manage teams
For service-specific scopes, refer to each service's documentation.
## Security Features
### Token Security
* **One-Time Display**: Token value shown only at creation
* **Secure Storage**: Tokens stored securely
* **Scope Validation**: Every request validates required permissions
### Expiration
* **Optional Expiration**: Set expiration date or create non-expiring keys
* **Flexibility**: Choose the expiration that fits your security needs
## Best Practices
Grant only the minimum scopes required for each use case
Create different keys for different applications or environments
Use clear names that indicate the key's purpose
Periodically rotate keys, especially for production use
Store keys in environment variables or secure vaults
Delete keys that are no longer needed
## Common Use Cases
### Development Environment
```bash theme={null}
# Create a key with full access for development
Scopes: ["*"]
Name: "Development - Local"
Expiration: 30 days
```
### Production Service
```bash theme={null}
# Create a key with service-level access
Scopes: ["service:*"]
Name: "Production - Service Access"
Expiration: Never
```
### CI/CD Pipeline
```bash theme={null}
# Create a key with specific permissions
Scopes: ["service:resource:write"]
Name: "GitHub Actions - Main Pipeline"
Expiration: 1 year
```
### Billing Portal Access
```bash theme={null}
# Create a key for billing management
Scopes: ["appcore:payment:update"]
Name: "Finance Tool - Billing Portal"
Expiration: Never
```
## Next Steps
Learn how to create your first API key
View, rotate, and revoke API keys
Complete list of available scopes
# API Key Scopes Reference
Source: https://docs.delino.io/core/api-keys/scopes
Complete reference of all available API key scopes and their permissions.
API key scopes control what operations an API key can perform. This page provides a comprehensive reference of all available scopes across Delino public APIs.
## Scope Format
Scopes follow the format: `service:resource:action`
* **service**: The Delino service (e.g., `real-prompter`)
* **resource**: The resource type (e.g., `project`, `prompt`, `chat`)
* **action**: The operation (e.g., `read`, `create`, `delete`)
## Wildcard Scopes
`*`
Grants access to all public API services and operations
`real-prompter:*`
Full access to Real Prompter service
## Real Prompter Scopes
Real Prompter provides prompt engineering through interactive conversations.
**Description**: Create new prompt projects
**Use Cases**:
* Automated project provisioning
* Integration tools that create projects
* Workflow automation
**Description**: View project information
**Use Cases**:
* Dashboard applications
* Project listing tools
* Monitoring systems
**Description**: Delete projects
**Use Cases**:
* Admin tools
* Cleanup automation
* Project management integrations
**Description**: Create and improve prompts
**Use Cases**:
* Prompt creation tools
* Automated prompt generation
* Content creation workflows
**Description**: View prompt content and versions
**Use Cases**:
* Prompt browsers
* Version control integrations
* Analytics tools
**Description**: Request prompt improvements
**Use Cases**:
* AI-assisted prompt optimization
* Automated refinement workflows
* Quality enhancement tools
**Description**: Revert to previous versions
**Use Cases**:
* Version management tools
* Rollback automation
* Change control systems
**Description**: Send messages in chat sessions
**Use Cases**:
* Chat bots
* Interactive applications
* Automated conversation tools
**Description**: View chat history
**Use Cases**:
* Chat viewers
* Analytics tools
* Conversation export tools
**Description**: Delete chat messages
**Use Cases**:
* Moderation tools
* Privacy management
* Data cleanup automation
**Description**: Create prompt subsets
**Use Cases**:
* Organization tools
* Categorization automation
* Workflow management
**Description**: View prompt subsets
**Use Cases**:
* Browsing tools
* Analytics dashboards
* Export utilities
**Description**: View project diagrams
**Use Cases**:
* Visualization tools
* Documentation generation
* Project overview displays
**Description**: All Real Prompter operations
Grants access to all Real Prompter service operations including projects, prompts, chats, subsets, and diagrams.
## Scope Validation
### How Scopes Are Validated
When an API request is made with an API key:
1. **Extract Token**: The API key token is extracted from the request
2. **Retrieve Scopes**: The key's scopes are fetched from the database
3. **Check Permission**: The required scope is checked against the key's scopes
4. **Wildcard Matching**: Wildcards are evaluated hierarchically
5. **Grant/Deny**: Access is granted or denied based on the match
### Validation Rules
```typescript Full Access theme={null}
// Scope: ["*"]
// Matches: Any operation on any service
hasPermission("*", "real-prompter:project:read") // ✅ true
hasPermission("*", "real-prompter:prompt:create") // ✅ true
hasPermission("*", "real-prompter:chat:send") // ✅ true
```
```typescript Service Access theme={null}
// Scope: ["real-prompter:*"]
// Matches: Any operation on Real Prompter service
hasPermission("real-prompter:*", "real-prompter:project:read") // ✅ true
hasPermission("real-prompter:*", "real-prompter:prompt:create") // ✅ true
hasPermission("real-prompter:*", "real-prompter:chat:send") // ✅ true
```
```typescript Resource Access theme={null}
// Scope: ["real-prompter:project:*"]
// Matches: Any action on Real Prompter projects
hasPermission("real-prompter:project:*", "real-prompter:project:read") // ✅ true
hasPermission("real-prompter:project:*", "real-prompter:project:create") // ✅ true
hasPermission("real-prompter:project:*", "real-prompter:prompt:read") // ❌ false
```
```typescript Specific Scope theme={null}
// Scope: ["real-prompter:prompt:read"]
// Matches: Only prompt reading
hasPermission("real-prompter:prompt:read", "real-prompter:prompt:read") // ✅ true
hasPermission("real-prompter:prompt:read", "real-prompter:prompt:create") // ❌ false
```
```typescript Multiple Scopes theme={null}
// Scope: ["real-prompter:project:read", "real-prompter:prompt:read"]
// Matches: Specific operations only
hasPermission(["..."], "real-prompter:project:read") // ✅ true
hasPermission(["..."], "real-prompter:prompt:read") // ✅ true
hasPermission(["..."], "real-prompter:prompt:create") // ❌ false
```
## Common Scope Combinations
### Read-Only Access
```json theme={null}
{
"scopes": [
"real-prompter:project:read",
"real-prompter:prompt:read",
"real-prompter:chat:read"
]
}
```
Perfect for dashboards and reporting tools that need to display project and prompt information.
### Content Creation
```json theme={null}
{
"scopes": [
"real-prompter:project:create",
"real-prompter:prompt:create",
"real-prompter:prompt:improve"
]
}
```
For tools that create and optimize prompts but don't need deletion permissions.
### Chat Bot Integration
```json theme={null}
{
"scopes": [
"real-prompter:chat:send",
"real-prompter:chat:read"
]
}
```
Enable interactive chat features without project management access.
### Full Project Management
```json theme={null}
{
"scopes": [
"real-prompter:project:*",
"real-prompter:prompt:*",
"real-prompter:subset:*"
]
}
```
Complete control over projects, prompts, and organization without chat access.
### Full Platform Access
```json theme={null}
{
"scopes": ["*"]
}
```
Complete access to all Real Prompter operations (use with caution).
## Best Practices
Begin with the minimum required scopes and add more only when needed.
**Example**: Start with `real-prompter:project:read` instead of `real-prompter:*`
For specific resources, use resource-level wildcards instead of service-level access.
**Example**: Use `real-prompter:project:*` instead of `real-prompter:*` if only managing projects
Create different keys for different purposes with appropriate scopes.
**Example**: Separate keys for read-only dashboards, chat bots, and project management
Document why each scope is needed in your internal documentation.
**Example**: "real-prompter:chat:send - Required for customer support chatbot integration"
Review scope assignments regularly and remove unnecessary permissions.
**Example**: Monthly audit of API keys and their scopes
## Next Steps
Create your first API key with appropriate scopes
Learn how to manage and rotate API keys
# Authentication Overview
Source: https://docs.delino.io/core/authentication/overview
Learn about Delino's secure authentication system with support for multiple authentication methods and API keys.
Delino provides secure authentication, offering safe access to the platform through multiple authentication methods. This guide covers authentication mechanisms, security features, and best practices.
## Authentication Methods
Delino supports two primary authentication methods:
**Dashboard Access**
* Email/password login
* Social login support
* Automatic session refresh
* Session management
* Secure token-based authentication
**Programmatic Access**
* Used for API and service integration
* Personal Access Tokens
* Fine-grained scope permissions
* Restricted to public APIs only
* No dashboard access
## Authentication Flow
### How Authentication Works
Delino's authentication flow:
User navigates to Delino and clicks "Sign In"
User directed to authentication page:
* Email/password login
* Social login options
System verifies credentials and validates user identity
User redirected back to Delino with active session:
* User record created/updated
* Session established
* Dashboard access granted
## API Key Authentication
### Personal Access Tokens (PATs)
API keys provide secure programmatic access:
API keys are **restricted to public APIs only**. They cannot access internal or admin endpoints.
**Key Features**:
* Created through Delino console
* Securely managed backend
* Fine-grained scope permissions
* Optional expiration (up to 100 years)
* Token value shown only once at creation
**Authentication Flow**:
```
API Request
├── Header: Authorization: Bearer deli_...
├── Extract token from header
├── Validate token
├── Verify scopes for requested operation
└── Grant/Deny access
```
### Scope-Based Authorization
API keys use scopes to control access:
**Format**: `service:resource:action`
**Examples**:
* `*` - Full access (development only)
* `service:*` - All operations for a specific service
* `service:resource:action` - Specific operation only
See [API Key Scopes](/core/api-keys/scopes) for complete reference.
### Public API Restriction
API keys (PATs) can only access **public APIs**. Private and admin endpoints require web session authentication.
**Public APIs** (accessible with API keys):
* Service-specific operations
* Usage reporting
* Resource management within scope
**Private APIs** (require web session):
* Admin operations
* User management
* System configuration
* Billing portal access (except via specific scope)
## API Key Security
API keys generated securely:
* Cryptographic random suffix (24 bits entropy)
* Unique internal names
* Collision-resistant
* Unpredictable values
API keys stored securely:
* Token value hashed
* Only shown once at creation
* Database stores hash only
* Cannot be recovered if lost
API keys transmitted securely:
* HTTPS only
* Authorization header
* Never in URL parameters
* Never in logs
API keys validated on every request:
* Token signature check
* Expiration verification
* Scope validation
## Session Management
### Web Sessions
Dashboard sessions managed automatically:
Typically 7-30 days with automatic refresh
Configurable per organization
Default: 30 minutes of inactivity
Multiple sessions allowed
Each device maintains separate session
### Session Features
* **Auto Refresh**: Sessions automatically refreshed before expiration
* **Remember Me**: Optional extended session duration
* **Multiple Devices**: Access from multiple devices simultaneously
## Security Best Practices
For your account:
* Minimum 12 characters
* Mix of letters, numbers, symbols
* Avoid common patterns
* Use password manager
Two-factor authentication:
* TOTP (Google Authenticator, etc.)
* SMS verification (if enabled)
* Backup codes
* Required for admin accounts
Regular API key rotation:
* Every 90-365 days
* After team member departure
* On security incident
* Document rotation schedule
Review active sessions:
* Check for unknown devices
* End inactive sessions
* Review login history
* Report suspicious activity
Apply principle of least privilege:
* Minimum required scopes for API keys
* Appropriate team roles
* Regular permission audits
* Remove unnecessary access
Protect authentication credentials:
* Never share passwords
* Never commit API keys to git
* Use environment variables
* Rotate on exposure
## Troubleshooting
### Cannot Log In
If you cannot log in to Delino:
1. **Verify Email**: Ensure using correct email address
2. **Reset Password**: Use password reset function
3. **Browser Issues**: Clear cache and cookies
4. **Contact Support**: If problem persists
### Session Errors
If you experience session issues:
1. **Session Expired**: Log out and log in again
2. **Clear Session**: Clear browser cache and cookies, then re-authenticate
3. **Contact Support**: If problem persists
### API Key Not Working
If API key authentication fails:
1. **Check Expiration**: Verify key hasn't expired
2. **Verify Scopes**: Ensure key has required permissions
3. **Public API**: Confirm endpoint is public (not admin)
4. **Header Format**: Use `Authorization: Bearer deli_...`
5. **Test Key**: Try simple API call to verify
## Next Steps
Learn how to create and manage API keys
Understand team-based authentication
# Billing Overview
Source: https://docs.delino.io/core/billing/overview
Understand Delino's billing system, subscription tiers, and payment processing.
Delino uses a transparent, credit-based billing system for payment processing. This guide covers subscription tiers, billing cycles, and how credits work.
## Billing System
### Credit-Based Model
Delino uses a credit system for precise usage tracking:
**\$1 USD = 1,000,000 credits**
All internal calculations use credits for precision, with conversion to USD only at invoice generation.
**Examples**:
```
$0.001 USD = 1,000 credits
$0.01 USD = 10,000 credits
$0.10 USD = 100,000 credits
$1.00 USD = 1,000,000 credits
$10.00 USD = 10,000,000 credits
```
### Why Credits?
Credits allow for sub-cent pricing without floating-point errors
Example: 150 credits = \$0.00015 USD (precise to 6 decimals)
Integer arithmetic is faster and more reliable than decimal calculations
All database operations use bigint for credits
No rounding errors or currency conversion issues
Credits are the single source of truth for billing
## Subscription Tier
Delino offers a Pro subscription tier for all accounts:
**Pro tier is required for all accounts** (both personal and team accounts)
**Pricing**: \$10/month
**Includes**:
* \$10 worth of credits (10,000,000 credits) per month
* Access to all services
* Priority support
* Advanced features
**Trial**:
* **Personal Pro**: 7-day free trial on first subscription
* **Team Pro**: No free trial, immediate payment required
**Usage Charges**: Pay-as-you-go for usage beyond included credits
**Checkout**: Handled through secure payment gateway
### Pro Tier Details
**Subscription**: \$10/month
**Free Trial**: 7 days on first subscription
**Included Credits**: \$10 (10,000,000 credits)
**Subscription**: \$10/month per team
**Free Trial**: None (immediate payment)
**Included Credits**: \$10 (10,000,000 credits)
## Billing Accounts
Every user and team has a separate billing account:
* **Personal Account**: Individual billing with 7-day trial
* **Team Account**: Team billing, no trial, immediate payment required
## Billing Cycle
Billing cycles are monthly, based on your account creation date. At the end of each cycle, credits are reset and a new billing period begins.
## Account Status
Billing accounts can have different statuses:
**Status**: Normal operation
**Characteristics**:
* Payment method configured
* Recent payment successful
* All services accessible
* No restrictions
**Actions**: None required
**Status**: Recent payment failed
**Characteristics**:
* Payment failure occurred
* 3-day grace period active
* Services still accessible
* Warning displayed
**Duration**: 3 days from payment failure
**Actions**: Update payment method before grace period ends
**Status**: Payment failed, grace period expired
**Characteristics**:
* Grace period expired without payment
* Services suspended
* No API access
* Data retained
**Actions**: Update payment method to restore service immediately
### Grace Period Details
3-day grace period on payment failure before service suspension
**Timeline**:
```
Day 0: Payment fails → Status: grace_period
Day 1: Grace period active → Services accessible
Day 2: Grace period active → Services accessible
Day 3: Grace period ends → Status: suspended
```
**During Grace Period**:
* All services remain accessible
* Warning messages displayed
* Email notifications sent
* Payment retry attempts
**After Grace Period**:
* Services immediately suspended
* API requests rejected
* Dashboard access limited
* Service restoration upon successful payment
## Next Steps
Learn how to monitor your usage and costs
# Usage Tracking
Source: https://docs.delino.io/core/billing/usage
Monitor your resource consumption and understand how usage is tracked and billed.
Delino tracks all resource usage, providing detailed insights into consumption across all services. This guide explains how to monitor your usage and optimize costs.
## Viewing Current Usage
### Dashboard Access
View your current billing cycle usage:
* **Personal Account**: `/teams/~/billing`
* **Team Account**: `/teams/[team-slug]/billing`
### Usage Display
Billing cycle start and end dates
**Example**: Sep 15, 2024 - Oct 14, 2024
Total credits consumed this cycle
**Format**: `1,234,567 credits`
Equivalent amount in USD
**Calculation**: `credits / 1,000,000`
**Example**: `1,234,567 credits = $1.23 USD`
Credits included in Pro subscription
**Pro Tier**: 10,000,000 credits (\$10)
Usage beyond included credits
**Calculation**: `(used_credits - included_credits) / 1,000,000`
**Example**:
```
Used: 15,000,000 credits
Included: 10,000,000 credits
Additional: 5,000,000 credits = $5.00 USD
```
### Service Breakdown
Usage is broken down by service with detailed metrics for each service you use. You can view:
* Service name
* Metric types (varies by service)
* Quantity consumed
* Credits charged
* Total cost in USD
## Usage Metrics
## Viewing Usage History
You can view your usage history through the billing dashboard:
1. Navigate to billing page (`/teams/~/billing` or `/teams/[team-slug]/billing`)
2. Select date range to view
3. Review usage by service and metric type
## Usage Optimization
### Best Practices
Check your usage regularly to stay within budget:
* Review weekly to catch unexpected usage
* Track trends over time
* Identify optimization opportunities
Reduce costs by optimizing how you use services:
* Cache results when possible
* Batch operations together
* Remove unused resources
At the end of each month:
* Review what drove your costs
* Adjust usage patterns as needed
* Plan for next month's budget
### Cost Optimization Tips
Process only what's needed
Avoid redundant operations
Cache results locally
Reduce repeat API calls
Group multiple operations
Reduce overhead costs
Use appropriate service tiers
Match resources to needs
Track usage patterns
Identify optimization opportunities
Remove unused resources
Delete old data and projects
## Troubleshooting
### Usage Not Appearing
If usage doesn't appear in the dashboard:
1. **Check Time Range**: Ensure you're viewing the current billing cycle
2. **Refresh Page**: Usage updates may take a few minutes to appear
3. **Contact Support**: If the issue persists after waiting
## Next Steps
Learn about subscription tiers and billing cycles
# Getting Started
Source: https://docs.delino.io/core/getting-started
Quick start guide to set up your Delino account, configure billing, and start using services.
This guide will walk you through setting up your Delino account, from initial signup to creating your first API key and making your first API call.
## Prerequisites
Before you begin, ensure you have:
* A valid email address
* A payment method (credit card, debit card, or supported payment method)
* Basic understanding of API concepts (for programmatic access)
## Step 1: Create Your Account
Go to [https://app.delino.io](https://app.delino.io)
Click the "Sign Up" button to begin registration
Register using one of the available methods:
**Choose a method**:
* Email and password
* Google account
**Enter required information**:
* Email address
* Password (if using email/password)
Check your email for verification link
Click the link to verify your email address
Your personal account is automatically created with the slug `~` (tilde)
## Step 2: Subscribe to Pro Tier
All new accounts require a Pro subscription (\$10/month). Personal accounts include a 7-day free trial.
Go to your billing settings:
* Click on your profile icon
* Select "Billing" or navigate to `/teams/~/billing`
Click "Upgrade to Pro" to begin your 7-day free trial
You won't be charged during the trial period
You'll be redirected to the payment checkout page:
**Enter payment information**:
* Credit/debit card number
* Expiration date
* CVV/CVC code
* Billing address
Payment method required even during trial for automatic subscription after trial ends
Review and confirm:
* Subscription: Personal Pro (\$10/month)
* Trial: 7 days free
* After trial: \$10/month + usage charges
Click "Subscribe" to complete
You're redirected back to Delino:
* Pro tier activated
* Trial period begins
* \$10 credits included (after trial)
* All services accessible
## Step 3: Explore the Dashboard
Familiarize yourself with the Delino dashboard:
**Dashboard Home**
* Current usage summary
* Recent activity
* Quick access to services
* Billing status
**Billing Page**
* Current billing cycle
* Credits used
* Service breakdown
* Upcoming invoice
**API Keys Page**
* Create new keys
* View existing keys
* Manage permissions
* Revoke keys
**Teams Page**
* View your teams
* Create new teams
* Manage team members
* Team settings
## Step 4: Create Your First API Key
Go to `/teams/~/api-keys` or click "API Keys" in the sidebar
Click the "New Key" button in the top-right
**Details Tab**:
* Name: `My First API Key`
* Expiration: Select "Never" or choose a date
**Permissions Tab**:
* Select "Full Access" for testing
* (You can create restricted keys later)
For production, use granular permissions instead of full access
Click "Create" to generate the key
**Important**: Copy the token value immediately
```
deli_abc123def456ghi789jkl012mno345pqr678stu901vwx234yz
```
This is the only time you'll see the full token value
Store it securely:
* Password manager
* Environment variable
* Secure vault
* **Never** in source code
## Step 5: Start Using Services
Now you can start using Delino's services through the web dashboard:
Navigate to the main dashboard to see available services
Browse available services and features:
* View service documentation
* Check pricing and usage
* Access service-specific features
Many services provide web interfaces for quick testing:
* Upload and process files
* Configure service settings
* View results in real-time
* Download processed outputs
When ready, use your API key to integrate services into your applications
See service-specific documentation for API details and code examples
Start with the web interface to understand how services work before integrating them into your code
## Step 6: Monitor Your Usage
Track your resource consumption:
Go to `/teams/~/billing`
See your current billing cycle:
* Credits used
* Amount in USD
* Service breakdown
* Remaining credits
Expand each service to see:
* Metric types
* Quantity consumed
* Credits charged
* Percentage of total
Download usage data:
* Select date range
* Choose format (CSV, JSON, PDF)
* Click "Export"
## Next Steps
Now that you have your account set up, explore these topics:
### For Individual Developers
Learn about API key scopes and security
Understand billing and pricing details
### For Teams
Set up a team for collaboration
Add team members and assign roles
## Common Questions
No, the 7-day trial is completely free. You'll only be charged after the trial ends if you continue using the Pro tier.
Yes, you can cancel anytime through the billing portal. Your services will continue until the end of your current billing cycle.
You'll be charged for additional usage on a pay-as-you-go basis. The $10/month includes $10 worth of credits (10,000,000 credits).
No, a payment method is required to subscribe to the Pro tier, which is mandatory for all accounts. However, you won't be charged during your 7-day trial.
First, create a team (separate from your personal account). Then navigate to the team's members page and click "Invite Member".
* **Personal Account** (slug: `~`): Your individual workspace, includes 7-day trial
* **Team Account**: Shared workspace for collaboration, no trial, requires payment upfront
Yes, you can create unlimited API keys. Best practice is to create separate keys for different applications or environments.
Navigate to `/teams/~/billing` and click on the "Invoices" tab. You can view, download, and export all your invoices.
## Need Help?
Contact support team
## Troubleshooting
### Login Issues
If you can't log in:
1. Verify your email address is correct
2. Use password reset if needed
3. Check spam folder for verification email
4. Clear browser cache and cookies
5. Try a different browser
### Payment Declined
If your payment is declined:
1. Verify card details are correct
2. Check with your bank for restrictions
3. Try a different payment method
4. Reach out to Delino support
### API Key Not Working
If your API key doesn't work:
1. Verify you copied the full token
2. Check the Authorization header format
3. Ensure key hasn't expired
4. Verify scopes include required permissions
5. Test with a simple API call
For more help, contact our [support team](mailto:support@delino.io).
# Overview
Source: https://docs.delino.io/core/overview
Learn about Delino's core platform features including authentication, teams, billing, and API management.
Delino Core provides the foundational infrastructure for managing your account, teams, billing, and API access. This comprehensive platform enables both individual developers and teams to collaborate, track usage, and manage resources efficiently.
## Key Features
### Authentication & Security
* **Secure Authentication**: Multiple authentication methods including email/password and social login
* **API Keys**: Personal Access Tokens for programmatic access with fine-grained permissions
### Team Collaboration
* **Personal & Team Accounts**: Support for individual developers and collaborative teams
* **Role-Based Access Control**: Owner, Admin, and Member roles with different permission levels
* **Team Invitations**: Email-based invitation system with secure tokens
### Billing & Subscriptions
* **Pro Subscription**: \$10/month with included credits
* **Credit-Based System**: 1 USD = 1,000,000 credits for precise usage tracking
* **Usage-Based Billing**: Pay-as-you-go pricing for all services
* **Secure Payment Processing**: Multiple payment methods supported
* **7-Day Free Trial**: Available for personal accounts
### Usage Tracking
* **Usage Monitoring**: Track resource consumption across all services
* **Detailed Reports**: View usage by service, metric type, and time period
* **Monthly Summaries**: Aggregated usage data for billing and analytics
## Account Structure
### Personal Accounts
Every user starts with a personal account (identified by the slug `~`) that includes:
* Individual billing account
* Personal API keys
* Pro subscription with 7-day trial option
### Teams
Teams enable collaboration with features like:
* Shared resources and billing
* Team member management with role-based permissions
* Team-specific API keys
* Separate usage tracking
## Getting Started
1. **Sign Up**: Create your account
2. **Choose Your Plan**: Start with the Pro tier (includes 7-day trial for personal accounts)
3. **Set Up Billing**: Configure your payment method
4. **Create API Keys**: Generate tokens for programmatic access
5. **Invite Team Members**: Build your team and assign roles
## Next Steps
Learn how to create and manage API keys for secure programmatic access
Discover how to create teams and collaborate with others
Understand subscription tiers, pricing, and usage tracking
Learn about authentication methods and security features
# Creating Teams
Source: https://docs.delino.io/core/teams/creation
Learn how to create teams, manage team members, and configure team settings.
Teams enable collaboration by allowing multiple users to share resources, billing, and access to Delino services. This guide covers creating teams.
## Prerequisites
Before creating a team, ensure you have:
Teams require a payment method at creation
**Teams**: Your payment method
**How to set up**: Visit billing settings and configure payment method
Think of a unique team slug (URL identifier)
**Requirements**:
* 4-20 characters
* Lowercase letters only
* Hyphens and numbers allowed
* Globally unique across all Delino teams
**Examples**: `engineering`, `data-team`, `team-42`
## Creating a Team
Teams are created by individual users for their projects:
Click "Teams" in the sidebar or go to `/teams`
Click the "New Team" button in the top-right corner
Fill in the team creation form:
**Team Name**
Display name for your team
**Example**: `Engineering Team`
Can be changed later in team settings
**Team Slug**
URL-friendly identifier (4-20 characters)
**Requirements**:
* Lowercase only
* Letters, numbers, hyphens
* Must be globally unique
**Example**: `engineering`
Cannot be changed after creation
**Subscription**: Team Pro (\$10/month)
**Payment Method**: Your configured payment method
**What's Included**:
* \$10 worth of credits per month (10,000,000 credits)
* Access to all Pro features
* Team collaboration tools
* Separate usage tracking
No free trial for teams (trial only for personal accounts)
Review your team details:
* Team name
* Team slug
* Subscription: \$10/month
* Payment method
Click "Create Team" to proceed
You'll be redirected to payment checkout:
**What happens**:
* Team Pro subscription (\$10/month)
* Immediate payment required (no trial)
* Payment method verified
* Subscription activated
Click "Subscribe" to complete
You're redirected back to Delino:
**Automatically configured**:
* Team created with your chosen slug
* You're added as Owner
* Billing account created
* Pro subscription active
* Ready to invite members
**Next steps**:
* Invite team members
* Create team API keys
* Start using team services
## Team Slug Guidelines
The team slug is a critical identifier that appears in URLs:
### Requirements
**4-20 characters**
✅ Valid: `team`, `engineering`, `data-science-2024`
❌ Invalid: `ai` (too short), `this-is-a-very-long-team-name-123` (too long)
**Lowercase letters, numbers, hyphens**
✅ Valid: `engineering`, `team-42`, `data-sci`
❌ Invalid: `Engineering` (uppercase), `team_42` (underscore), `team.42` (period)
**Globally unique across all Delino teams**
If slug is taken, try:
* Adding numbers: `engineering-2`, `engineering-2024`
* Adding organization: `acme-engineering`
* Using abbreviations: `eng-team`, `data-sci`
### Best Practices
Use names that clearly identify the team's purpose
**Good**: `frontend-team`, `data-science`
**Bad**: `team1`, `abc`
Shorter slugs are easier to remember and type
**Good**: `eng`, `data`
**Bad**: `engineering-department-team`
Don't include years or dates that become outdated
**Good**: `marketing`
**Bad**: `marketing-2024`
Choose names that scale with your organization
**Good**: `engineering`, `sales`
**Bad**: `johns-team`, `temp-project`
### Common Slug Patterns
Department-based naming:
* `engineering`
* `marketing`
* `sales`
* `finance`
* `hr`
Function-based naming:
* `frontend`
* `backend`
* `devops`
* `qa`
* `data-science`
Product-based naming:
* `product-a`
* `mobile-app`
* `web-platform`
* `api-team`
Location-based naming:
* `us-west`
* `emea`
* `apac`
* `remote`
## What Happens After Creation
Once your team is created:
### 1. Team Structure
```
Team: engineering
├── Members
│ └── You (Owner)
├── Billing Account
│ ├── Type: team
│ ├── Tier: Pro ($10/month)
│ └── Credits: 10,000,000/month
├── API Keys
│ └── (None - create as needed)
└── Resources
└── (None - add as needed)
```
### 2. Immediate Actions
Add team members and assign roles
Navigate to `/teams/[slug]/members`
Generate API keys for team services
Navigate to `/teams/[slug]/api-keys`
Update team name and preferences
Navigate to `/teams/[slug]/settings`
Track team resource consumption
Navigate to `/teams/[slug]/billing`
### 3. Team URLs
Your team is accessible at:
```
Dashboard: /teams/[slug]
Members: /teams/[slug]/members
API Keys: /teams/[slug]/api-keys
Billing: /teams/[slug]/billing
Settings: /teams/[slug]/settings
```
**Example** (slug: `engineering`):
```
/teams/engineering
/teams/engineering/members
/teams/engineering/api-keys
/teams/engineering/billing
/teams/engineering/settings
```
## Billing for Teams
### Teams
**Team Pro**: \$10/month
**None** (trials only for personal accounts)
**10,000,000 credits** (\$10 worth)
**Your payment method**
**Pay-as-you-go** for usage beyond included credits
## Troubleshooting
### Slug Already Taken
If your desired slug is unavailable:
1. **Try variations**:
* Add numbers: `engineering-2`
* Add organization: `acme-engineering`
* Use abbreviations: `eng-team`
2. **Check availability**: The form will show if slug is taken
3. **Choose unique identifier**: Make it specific to your use case
### Payment Required Error
If you get a payment error:
1. **Configure payment method**: Set up payment in billing settings
2. **Check payment status**: Ensure payment method is valid
3. **Contact support**: If problem persists
### Billing Declined
If team creation fails due to billing:
1. **Verify payment method**: Check card details
2. **Check balance**: Ensure sufficient funds
3. **Try different card**: Use alternative payment method
4. **Contact bank**: Payment may be blocked
5. **Reach support**: Contact Delino support
## Team Limits
**Unlimited**
No hard limit on team size
**Unlimited**
Create as many API keys as needed
## Next Steps
Add team members and assign roles
Create API keys for team services
Monitor team usage and billing
# Managing Team Members
Source: https://docs.delino.io/core/teams/members
Learn how to invite, manage roles, and remove team members.
Effective team member management is crucial for collaboration and security. This guide covers inviting members, managing roles, and handling member lifecycle.
## Viewing Team Members
Navigate to your team's members page:
* **URL Pattern**: `/teams/[team-slug]/members`
* **Example**: `/teams/engineering/members`
### Member Information
Each team member entry shows:
Member profile information
* Name
* Email address
* Avatar (if available)
Current role assignment
* Owner
* Admin
* Member
When the member joined the team
Available actions based on your role
* Change role (Admin/Owner only)
* Remove member (Admin/Owner only)
## Inviting Team Members
Only Owners and Admins can invite new members
### Invitation Process
Go to `/teams/[team-slug]/members`
Click the "Invite Member" button in the top-right
Fill in the invitation form:
Email address of the person to invite
Must be a valid email address
Role to assign to the new member
Options:
* Member (default)
* Admin
* Owner
Click "Send Invitation"
The system will:
* Validate the email address
* Check for existing membership
* Generate a secure invitation token
* Send invitation email via Plunk
Monitor invitation status in the Invitations tab
Statuses:
* Pending
* Accepted
* Expired (after 24 hours)
* Cancelled
### Invitation Email
Recipients receive an email containing:
```
Subject: You've been invited to join [Team Name]
[Inviter Name] has invited you to join [Team Name] as a [Role].
[Accept Invitation Button]
This invitation expires in 24 hours.
```
**Email Contents**:
* Team name
* Inviter's name
* Assigned role
* Secure invitation link with token
* Expiration time (24 hours)
* Delino branding
### Invitation Validation
The system validates several conditions:
Email must be a valid format
✅ Valid: `user@example.com`
❌ Invalid: `not-an-email`
User cannot already be a team member
If the user is already a member, change their role instead
User cannot have a pending invitation
If an invitation exists, resend it instead
Maximum 50 pending invitations per team
Cancel or wait for expired invitations to free up slots
Only Admins and Owners can send invitations
Members cannot invite others
## Managing Invitations
### Viewing Pending Invitations
Navigate to the Invitations tab on the members page:
Email address of the invited user
Role that will be assigned when accepted
Name of the team member who sent the invitation
When the invitation was sent
When the invitation will expire (24 hours from sent time)
Current invitation status
* Pending
* Accepted
* Expired
* Cancelled
### Resending Invitations
If a member didn't receive the invitation email:
1. Navigate to Invitations tab
2. Find the pending invitation
3. Click "Resend"
Resending uses the **same token and expiration time**. It doesn't extend the 24-hour deadline.
### Cancelling Invitations
To cancel a pending invitation:
1. Navigate to Invitations tab
2. Find the invitation to cancel
3. Click "Cancel"
The invitation is immediately invalidated and the link becomes unusable.
## Changing Member Roles
Only Owners and Admins can change roles. Admins cannot modify Owner roles.
### Role Change Process
Go to the team members page
Find the member whose role you want to change
Click the actions menu (⋮) for that member
Choose the new role:
* Member
* Admin
* Owner
Confirm the role change
The change takes effect immediately
### Role Change Permissions
| Your Role | Can Change To |
| --------- | ------------------------------------ |
| Owner | Any role for any member |
| Admin | Member ↔ Admin (cannot touch Owners) |
| Member | None (no permission) |
### Role Change Restrictions
Cannot remove or demote the last Owner
**Error**: "Team must have at least one Owner"
**Solution**: Promote another member to Owner first
Admins cannot modify Owners
**Error**: "Insufficient permissions"
**Solution**: Ask an Owner to make the change
Owners can demote themselves if other Owners exist
Be careful not to lock yourself out
## Removing Team Members
Removing a member immediately revokes their access to all team resources
### Removal Process
Go to the team members page
Find the member to remove
Click the actions menu (⋮) for that member
Select "Remove from team"
Confirm the removal
The member is immediately removed
### What Happens When Removed
When a member is removed:
1. **Immediate Access Revocation**: All team access is revoked
2. **API Keys**: Team API keys no longer work for the removed user
3. **Resources**: No longer can access team resources
4. **Billing**: No longer counts toward team billing
5. **Audit Log**: Removal is recorded in audit logs
The user's personal account and personal teams are not affected
### Removal Restrictions
Cannot remove the last Owner
**Error**: "Team must have at least one Owner"
**Solution**: Promote another member to Owner first, or delete the team
Only Admins and Owners can remove members
Admins cannot remove Owners
Members can leave teams voluntarily
Navigate to team settings → "Leave Team"
## Offboarding Members
### Offboarding Checklist
When a team member leaves:
Audit what resources the member had access to
* Team API keys they created
* Services they used
* Projects they worked on
If needed, transfer ownership of resources
* Reassign projects
* Transfer API key ownership
* Update documentation
Rotate any shared credentials
* Team API keys
* Service credentials
* Deployment keys
Remove the member from the team
Confirm access is revoked
* Test API keys
* Check resource access
* Review audit logs
Update team documentation
* Remove from team roster
* Update contact lists
* Archive relevant communications
### Emergency Removal
For immediate security concerns:
1. **Remove member immediately** from the team
2. **Revoke all API keys** they had access to
3. **Rotate credentials** for all shared services
4. **Review audit logs** for suspicious activity
5. **Notify team** of the security incident
6. **Document the incident** for future reference
## Member Limits and Quotas
No hard limit
Teams can have unlimited members
Maximum 50 per team
Rate limit to prevent abuse
24 hours
Invitations automatically expire after 24 hours
At least 1 Owner required
Cannot remove or demote the last Owner
## Best Practices
Grant minimum role needed for each member's responsibilities
Review team membership monthly to remove inactive members
Document what each role can do in your team
Create onboarding documentation for new members
Have 2-3 Owners to prevent lockout scenarios
Remove departing members within 24 hours
## Troubleshooting
### Invitation Not Received
If a member didn't receive the invitation email:
1. **Check spam folder**: Invitation may be filtered
2. **Verify email address**: Ensure it's correct
3. **Resend invitation**: Use the resend feature
4. **Check Plunk status**: Verify email service is operational
5. **Contact support**: If problem persists
### Cannot Change Role
If you can't change a member's role:
1. **Check your role**: Only Admins and Owners can change roles
2. **Target role**: Admins cannot modify Owners
3. **Last Owner**: Cannot demote the last Owner
4. **Permission error**: Verify your permissions
### Cannot Remove Member
If you can't remove a member:
1. **Last Owner**: Cannot remove the last Owner
2. **Permission check**: Verify you're an Admin or Owner
3. **Admin limitations**: Admins cannot remove Owners
4. **Contact Owner**: Ask an Owner to perform the action
## Next Steps
Manage team API keys for programmatic access
Understand team billing and usage
# Teams Overview
Source: https://docs.delino.io/core/teams/overview
Learn about teams, collaboration features, and how to manage team members effectively.
Teams enable collaboration by allowing multiple users to share resources, billing, and access to Delino services. Teams provide the structure needed for effective collaboration.
## Team Features
Teams created by individual users for their projects:
* Creator is automatically the owner
* Individual billing account
* Shared resources and billing among members
## Team Roles
Teams use role-based access control (RBAC) to manage permissions:
**Full Control**: Complete administrative access
**Permissions**:
* All Admin permissions
* Delete team
* Transfer ownership
* Change billing settings
* Remove other owners
**Limits**: Each team must have at least one owner
**Team Management**: Administrative tasks without destructive actions
**Permissions**:
* All Member permissions
* Invite and remove members
* Update team settings
* Manage team API keys
* View billing information
* Change member roles (except Owner)
**Limits**: Cannot delete team or modify owners
**Standard Access**: Use team resources
**Permissions**:
* Access team resources
* View team information
* Use team services
* View own membership details
**Limits**: Cannot manage team or members
## Team Features
### Shared Resources
* **Unified Billing**: All team members share the same billing account
* **API Keys**: Team-level API keys accessible to all members
* **Services**: Shared access to Delino services
* **Usage Tracking**: Consolidated usage across all team activities
### Collaboration
* **Member Invitations**: Email-based invitation system
* **Role Management**: Flexible permission assignment
* **Team Dashboard**: Centralized view of team activity
* **Usage Reports**: Track team resource consumption
### Security
* **Role-Based Access**: Granular permission control
* **Audit Logging**: Track team management actions
* **Secure Invitations**: Token-based invitation system with expiration
## Team Structure
Every user has a personal account (slug: `~`) that serves as their individual workspace:
* Personal billing account
* Personal API keys
* Individual usage tracking
Users can create and join multiple teams, each with its own billing and resources.
## Team Slugs
Each team has a globally unique slug used for URL routing:
URL-friendly team identifier
**Requirements**:
* 4-20 characters
* Lowercase letters only
* Hyphens allowed
* Numbers allowed
* Must be globally unique
**Examples**:
* `engineering` ✅
* `data-team` ✅
* `team-42` ✅
* `Team` ❌ (uppercase)
* `ai` ❌ (too short)
* `Engineering` ❌ (uppercase)
The slug `~` is reserved for personal accounts
## Team Billing
### Subscription Requirements
All teams require a Pro subscription (\$10/month) with a configured payment method.
**Teams**:
* Require Pro subscription
* No free trial for teams (trial only for personal account)
* Payment method required at creation
### Billing Structure
```
Team
├── Billing Account (team)
├── Pro Subscription ($10/month)
├── Included Credits ($10)
└── Usage Charges (pay-as-you-go)
```
## Team Invitations
### Invitation Flow
Admin or Owner invites a member by email through the team members page
Invitation email sent with:
* Team name and inviter information
* Assigned role
* Secure invitation link
* 24-hour expiration notice
Recipient clicks link and accepts
* Email must match invitation
* Token must be valid and not expired
* User added to team with specified role
## Team Limits
No hard limit on team size
Teams can have unlimited members
Maximum 50 pending invitations per team
Rate limit to prevent spam and abuse
4-20 characters
Must be globally unique across all teams
## Best Practices
Use descriptive team names and slugs that identify the team's purpose
Assign roles based on principle of least privilege
Review team members and permissions quarterly
Establish clear onboarding process for new members
Remove departing members promptly and rotate shared keys
Track team usage to optimize costs and resources
## Next Steps
Learn how to create your first team
Add, remove, and manage team members
# Claude Code
Source: https://docs.delino.io/devbird/ai-agents/claude-code
Setup and usage guide for Claude Code with DevBird
This guide covers connecting Claude Code to your repository. To set up DevBird
itself, please refer to the [DevBird setup
guide](/devbird/getting-started/prerequisites).
Claude Code is Anthropic's AI coding assistant. When integrated with DevBird, it can automate code generation, bug fixes, refactoring, and more through natural language commands.
## Prerequisites
Before you begin, ensure you have:
* Claude Code installed on your machine
* A Claude subscription (recommended for long-lived token option)
* Repository access where you want to use DevBird
## Setup Process
### Step 1: Launch Claude Code
1. Open Claude Code
2. Navigate to your project directory
### Step 2: Install GitHub App
1. In the Claude Code terminal, run:
```bash theme={null}
/install-github-app
```
2. A browser window will open automatically
### Step 3: Select Repository
Select the repository where you want to use DevBird from the list presented.
### Step 4: Install GitHub App
Follow the GitHub prompts to install the DevBird app to your selected repository.
### Step 5: Configure Workflows
When Claude Code displays the `Select GitHub workflows to install` screen, press Enter to continue with the default workflow selection.
### Step 6: Choose Authentication Method
Claude Code will present the `Install GitHub App` screen with authentication options:
* **Create a long-lived token with your Claude subscription** (Recommended)
* Uses your existing Claude subscription (flat rate billing)
* More cost-effective for regular use
* Requires approval on the Anthropic website
* **Enter a new API key**
* Pay-as-you-go pricing model
* Charges based on usage
We recommend the long-lived token option if you have a Claude subscription, as
it provides predictable costs.
### Step 7: Approve on Anthropic Website
If you selected the long-lived token option, approve the connection on the Anthropic website when prompted.
### Step 8: Handle Setup Pull Request
Claude Code will automatically create a setup pull request in your repository:
* **If you plan to use Claude Code directly**: Review and merge the PR
* **If you only plan to use DevBird (without using Claude Code directly)**: You don't need this PR - you can close it without merging
* **If you're just testing**: You can close the PR without merging
## Next Steps
* [Create your first PR](/devbird/getting-started/first-pr)
* [Unit Task Guide](/devbird/tasks/unit)
* [Composite Task Guide](/devbird/tasks/composite)
# Codex CLI by OpenAI
Source: https://docs.delino.io/devbird/ai-agents/codex-cli
Setup and usage guide for Codex CLI with DevBird
This guide covers connecting Codex CLI to your repository. To set up DevBird
itself, please refer to the [DevBird setup
guide](/devbird/getting-started/prerequisites).
Codex CLI is OpenAI's AI coding assistant. When integrated with DevBird, it can automate code generation, bug fixes, refactoring, and more through natural language commands.
## Prerequisites
Before you begin, ensure you have:
* An OpenAI account
* Repository access where you want to use DevBird
## Setup Process
### Step 1: Generate OpenAI API Key
1. Go to the [OpenAI API keys page](https://platform.openai.com/api-keys)
2. Click **Create new secret key**
3. Give your key a descriptive name (e.g., "DevBird")
4. Copy the generated API key (you won't be able to see it again)
### Step 2: Add API Key to GitHub Repository
1. Navigate to your repository on GitHub
2. Go to **Settings** > **Secrets and variables** > **Actions**
3. Click **New repository secret**
4. Set the name to `OPENAI_API_KEY`
5. Paste your OpenAI API key in the value field
6. Click **Add secret**
## Next Steps
* [Create your first PR](/devbird/getting-started/first-pr)
* [Unit Task Guide](/devbird/tasks/unit)
* [Composite Task Guide](/devbird/tasks/composite)
# Crush CLI (WIP)
Source: https://docs.delino.io/devbird/ai-agents/crush-cli
WIP:
# Gemini CLI (WIP)
Source: https://docs.delino.io/devbird/ai-agents/gemini-cli
WIP:
# GitHub Copilot CLI (WIP)
Source: https://docs.delino.io/devbird/ai-agents/github-copilot-cli
WIP:
# opencode (WIP)
Source: https://docs.delino.io/devbird/ai-agents/opencode
WIP:
# Webhook Architecture
Source: https://docs.delino.io/devbird/architecture/webhook
Learn how DevBird processes webhooks from Git providers
## Overview
DevBird uses webhooks to receive real-time notifications from GitHub about events in your repositories. This enables DevBird to automatically respond to pull request reviews, CI status changes, and other repository events.
## GitHub Webhooks
DevBird uses GitHub App webhooks to receive events:
* Uses GitHub App webhooks or repository webhooks
* Validates webhook signatures using the webhook secret
* Receives events via the GitHub App installation
## Webhook Events
DevBird listens for the following webhook events:
### Pull Request Events
* **Pull Request Opened**: Triggered when a new PR is created
* DevBird posts task context as a comment
* Links the PR to the originating task
* **Pull Request Closed**: Triggered when a PR is merged or closed
* Updates task status
* Triggers completion notifications if all PRs are merged
* **Pull Request Synchronized**: Triggered when new commits are pushed
* Updates PR status in DevBird
### Review Events
* **Pull Request Review Submitted**: Triggered when a review is posted
* DevBird analyzes review comments
* Triggers AI agent to address feedback
* Creates new commits to address comments
* **Pull Request Review Comment**: Triggered when inline comments are added
* Triggers targeted code fixes for specific comments
### Status Events
* **Check Run Completed**: Triggered when CI checks finish
* DevBird monitors for failures
* Automatically triggers CI fix workflow for failed checks
* Undrafts PR when all checks pass (if auto-undraft is enabled)
* **Status**: Legacy status API events
* Backward compatibility for older CI systems
# ChangeLog
Source: https://docs.delino.io/devbird/changelog
Track updates and improvements to DevBird
## December 26, 2025
### Security Enhancement: Environment Variable Filtering
Added documentation for environment variable filtering in the GitHub workflow to improve security when working with AI agents.
**Changes:**
* Added `DEVBIRD: 1` environment variable to the workflow configuration
* Documented best practices for filtering environment variables to only safe prefixes (`NEXT_PUBLIC_*` and `TEST_*`)
* Added example script for filtering `.env` files in DevBird mode
* Explained security rationale for limiting AI agent access to environment variables
**Documentation updated:**
* [GitHub Workflow](/devbird/getting-started/github-workflow) - Added "Filter environment variables for security" section
# Comparison with other tools
Source: https://docs.delino.io/devbird/comparison
Compare DevBird with Claude Code Web and Codex CLI to find the best tool for your workflow
## Feature Comparison
Here's how it compares to other popular web-based AI agents.
| Feature | DevBird | Claude Code Web | Codex Web |
| ------------------------------------ | :-------------------------------------------------------: | :-------------: | :----------: |
| **AI environment** | | | |
| - **Runs on** | GitHub Actions | Cloud | Cloud |
| - **Using own device** | ✅ , via Custom Runner | ❌ | ❌ |
| - **Configuring** | [`devbird.yml`](/devbird/getting-started/github-workflow) | ✅ (No setup) | ✅ (No setup) |
| - **Customization** | ✅,via github actions | ❌ | ❌ |
| **Iteration (Feedback loop)** | ✅, Semi-automated | Manual | Manual |
| - **Automatic CI fix** | ✅ | ❌ | ❌ |
| - **Automatic PR Review reflection** | ✅ | ❌ | ❌ |
| **AI Agent** | ✅, Anything | Claude Code | Codex CLI |
| - **AI Model** | ✅, Anything | Anthropic-only | OpenAI-only |
| **Task decomposition** | ✅ | ❌ | ❌ |
| **Extension** | | | |
| - **API** | 🚧 (WIP) | ❌ | ❌ |
# Custom GitHub Actions Runner
Source: https://docs.delino.io/devbird/cost-reduction/github-runner
# Configuring AI Agent
Source: https://docs.delino.io/devbird/getting-started/ai-agent
Learn how to configure AI agents for your DevBird workflow
DevBird supports multiple AI agent providers to power your development automation. Choose the right agent based on your use case and budget.
## Supported AI Agents
You can configure the following AI agents in DevBird:
* [Claude Code](/devbird/ai-agents/claude-code)
* [Codex CLI](/devbird/ai-agents/codex-cli)
* [Crush CLI (WIP)](/devbird/ai-agents/crush-cli)
* [Gemini CLI (WIP)](/devbird/ai-agents/gemini-cli)
* [GitHub Copilot CLI (WIP)](/devbird/ai-agents/github-copilot-cli)
* [OpenCode (WIP)](/devbird/ai-agents/opencode)
## Recommendations
### For Testing & Experimentation
If you're testing DevBird or evaluating its capabilities, we recommend **OpenAI Codex with API Key** configuration:
* Quick setup with just an API key
* Pay-per-use pricing
* Good performance for basic automation tasks
* No subscription commitment required
### For Production Use
If you're serious about using DevBird in your development workflow, we strongly recommend **Claude Code with Max Plan**:
* Superior code understanding and generation
* Best-in-class context handling
* Optimized for complex refactoring and architectural tasks
* Higher usage limits with Max subscription
* Most reliable for production workflows
## Using Multiple Agents
You can configure multiple AI agents in your GitHub repository. Once configured, you can select which agent to use for each task directly within the DevBird app.
# Creating Your First PR
Source: https://docs.delino.io/devbird/getting-started/first-pr
Step-by-step guide to creating your first AI-generated pull request with DevBird
This guide walks you through creating your first pull request with DevBird.
## Prerequisites
Before starting, ensure you've completed:
1. ✅ [Prerequisites](/devbird/getting-started/prerequisites)
2. ✅ [GitHub App Installation](/devbird/getting-started/github-app)
3. ✅ [GitHub Workflow Setup](/devbird/getting-started/github-workflow)
4. ✅ [AI Agent Configuration](/devbird/getting-started/ai-agent)
## Step 1: Access DevBird Dashboard
1. Go to [app.delino.io](https://app.delino.io)
2. Select your team from the team switcher
3. Navigate to the DevBird section
4. You'll see the task creation form
## Step 2: Select Your Repository
1. Click the **Repository** dropdown
2. Select the repository where you want to create a PR
3. Only repositories with the DevBird GitHub App installed will appear
**Troubleshooting**: If your repository doesn't appear:
* Verify GitHub App installation
* Check repository permissions
* Refresh the page
## Step 3: Write Your Task Prompt
Start with a simple, well-defined task for your first PR:
### Example 1: Bug Fix
```
Fix the authentication bug where users get a 500 error
when logging in with an empty email field. Add proper
validation and return a 400 error with helpful message.
```
### Example 2: Small Feature
```
Add a dark mode toggle button to the settings page.
Store the preference in localStorage and apply the
theme across all pages.
```
### Example 3: Refactoring
```
Refactor the payment processing service to use async/await
instead of callbacks. Update all related functions in
@src/services/payment.js
```
**Tips for good prompts:**
* Be specific about what to fix or build
* Include file paths using `@` notation
* Mention technical requirements
* Specify expected behavior
## Step 4: Configure Task Settings
### Task Type
For your first PR, **leave "Create as Composite Task" unchecked**.
This creates a simple unit task, perfect for getting started.
### Advanced Settings (Optional)
**AI Agent**:
* Leave blank to use your team's default
* Or select a specific agent (e.g., "Claude Code")
**Model Version**:
* Leave blank to use the agent's default
* Or specify a model (e.g., "sonnet", "gpt-4")
**Base Branch**:
* Leave blank to use the repository's default branch
* Or specify a branch (e.g., "develop", "staging")
## Step 5: Create the Task
1. Review your prompt
2. Check repository selection
3. Click **Create Task**
4. You'll be redirected to the task details page
## Step 6: Monitor Progress
The task details page shows:
### Initial Status: Pending
* Task is created and queued
* GitHub Actions workflow is being triggered
* Usually completes in seconds
### Status: In Progress
* AI agent is analyzing your request
* Code is being written
* Pull requests are being created
* This can take 2-10 minutes depending on complexity
### Status: Completed
* All work is done
* Pull requests have been created
* Ready for review
## Step 7: Review the Generated PR
Once completed:
1. Click on the PR in the task details page
2. Or navigate to GitHub and find the PR
3. Review the changes:
* Check code quality
* Verify it meets requirements
* Look for any issues
### What to expect
**On GitHub PR page:**
* DevBird task link comment
* Task prompt comment (shows what AI was asked to do)
* Code changes in files
* Automated tests running (CI checks)
**Good signs:**
* Code follows your project's style
* Tests are passing
* Changes are focused and relevant
* Documentation is updated if needed
**Red flags:**
* Code doesn't compile
* Tests are failing
* Changes are unrelated to the task
* Security issues
## Step 8: Provide Feedback (Optional)
If changes are needed:
### Option 1: GitHub Review Comments
1. Leave review comments on the PR
2. Click "Request changes" or "Comment"
3. DevBird automatically detects the review
4. AI agent makes updates based on your feedback
5. PR is updated with new changes
### Option 2: Manual Update Request
1. Go to task details page
2. Click **Update PR**
3. Enter update instructions
4. DevBird triggers update workflow
5. PR is updated with changes
## Step 9: Merge the PR
When you're satisfied:
1. Ensure all CI checks pass
2. Get required approvals from team
3. Merge the PR on GitHub
4. Delete the branch (optional)
5. Task status updates to "Completed"
## Common First-Time Issues
### DevBird not responding to reviews
**Causes**:
* `devbird.yml` file missing or incorrect
* Agent not configured or API key missing
**Solution**:
* Verify workflow file exists at `.github/workflows/devbird.yml`
* Check file contents match the setup guide
* Ensure workflow has correct permissions
* Verify AI agent is set up correctly
* Check API key in repository secrets
* Review agent configuration guide
### PR not created
**Cause**: Task completed but no branches were needed
**Solution**:
* Check task prompt - was it clear what to create?
* Review workflow execution logs
* Task may have determined no changes were needed
### CI checks failing
**Cause**: Generated code has issues
**Solution**:
* DevBird automatically tries to fix CI failures
* Wait for auto-fix workflow to complete
* If it fails again, add review comments with guidance
## Next Steps
Now that you've created your first PR:
### Try more complex tasks
* [Unit Tasks Guide](/devbird/tasks/unit)
* [Composite Tasks Guide](/devbird/tasks/composite)
### Learn about PR management
* [PR Review Process](/devbird/reviewing-prs)
* [Settings Configuration](/devbird/settings)
### Optimize your workflow
* [AI Agent Configuration](/devbird/ai-agents/claude-code)
* [Troubleshooting Guide](/devbird/troubleshooting/unit-task)
### Advanced features
* Try creating a composite task for complex projects
* Enable auto-approval for trusted workflows
* Configure custom CI fix strategies
## Tips for Success
### Start simple
* Begin with small, well-defined tasks
* Learn how the AI interprets your prompts
* Gradually increase complexity
### Iterate on prompts
* Refine your prompt writing based on results
* Be more specific if output is too broad
* Add constraints for better control
### Review carefully
* Always review AI-generated code
* Don't merge without understanding changes
* Treat it like code from a junior developer
### Collaborate with AI
* Use DevBird for repetitive tasks
* Let it handle boilerplate code
* Focus your time on complex logic and architecture
### Provide feedback
* Review comments help the AI improve
* Be specific about what's wrong
* Guide the AI toward better solutions
## Example: Complete First Task
Let's walk through a complete example:
**Prompt:**
```
Add input validation to the user registration form.
Email must be valid format, password must be at least
8 characters. Display error messages below each field.
```
**What happens:**
1. Task created with auto-generated title: "Add input validation to user registration form"
2. GitHub Actions workflow triggered
3. AI agent analyzes the codebase
4. Finds the registration form component
5. Adds validation logic
6. Adds error message display
7. Writes tests for validation
8. Creates PR with all changes
**Expected PR:**
* Frontend: Validation logic in registration component
* Frontend: Error message UI components
* Tests: Validation test cases
* Total: \~100-200 lines across 3-4 files
**Review:**
1. Check validation logic is correct
2. Verify error messages are user-friendly
3. Ensure tests cover edge cases
4. Confirm no breaking changes
**Result:**
* PR merged
* Feature deployed
* Task completed
**Time saved:** \~1-2 hours of development work
You're now ready to use DevBird for your development tasks!
# Installing GitHub App
Source: https://docs.delino.io/devbird/getting-started/github-app
Connect your GitHub repositories to DevBird by installing the GitHub App
## Prerequisites
Before you begin, ensure you have:
* An active DevBird account
* Admin access to the GitHub organization or repository you want to connect
* A GitHub account linked to your organization
## Installing the GitHub App
Follow these steps to connect your GitHub repositories to DevBird:
### 1. Navigate to Repositories
In the DevBird app, select the **Repositories** menu from the navigation.
### 2. Connect your GitHub account
Click on the option to connect your GitHub account. You'll be redirected to GitHub to authorize the connection.
### 3. Install the GitHub App
Click **Install GitHub App** to begin the installation process.
When prompted to select repositories:
* We recommend selecting **Only select repositories**
* Choose only the repositories you plan to use with DevBird
* This limits the app's access to only what you need
### 4. Connect repositories in DevBird
After installation, return to the DevBird app and select the repositories you want to use from the list of available repositories.
## Next steps
Once you've connected your repositories, you can start using DevBird to automate your development workflow.
# Adding GitHub Workflow
Source: https://docs.delino.io/devbird/getting-started/github-workflow
Set up the DevBird GitHub Workflow in your repository to automate development tasks
Recently `autodev.yml` is renamed to `devbird.yml` because the product is
rebranded. But for backward compatibility, `autodev.yml` will just work as
before.
## Prerequisites
Before you begin, ensure you have:
* Completed the [GitHub App installation](/devbird/getting-started/github-app)
* Admin or write access to your repository
* Required secrets configured in your GitHub repository
## Setting up the workflow
Follow these steps to add the DevBird workflow to your repository:
### 1. Create the workflow file
Create a new file at `.github/workflows/devbird.yml` in your repository.
### 2. Add the workflow configuration
Copy the following YAML configuration into the file:
```yaml theme={null}
name: "DevBird"
run-name: "DevBird: ${{ inputs.task_title }}"
on:
workflow_dispatch:
inputs:
prompt:
description: "Instructions for DevBird. Can be a direct prompt or custom template."
type: string
required: true
base_branch:
description: "The branch to use as the base/source when creating new branches (defaults to repository default branch)"
type: string
required: false
default: "main"
agent:
description: "The agent to use for the action. Can be 'claude_code', 'gemini_cli', 'codex_cli' or 'opencode'"
type: choice
default: "claude_code"
options:
- claude_code
- gemini_cli
- codex_cli
- opencode
- crush_cli
- github_copilot_cli
agent_model:
description: "The (optional) model to use for the agent"
type: string
required: false
default: ""
devbird_workflow_execution_token:
description: "The token to use for the DevBird task"
type: string
required: false
default: ""
devbird_mode:
description: "The DevBird execution mode. Can be 'develop' (default) or 'plan' (for task graph planning)"
type: choice
default: "develop"
options:
- develop
- plan
task_title:
description: "The title of the DevBird task"
type: string
required: false
default: ""
jobs:
devbird:
runs-on: ubuntu-latest
env:
DEVBIRD: 1
permissions:
contents: write
pull-requests: write
issues: write
id-token: write
actions: read # Required for Claude to read CI results on PRs
steps:
- name: Checkout code
uses: actions/checkout@v5
# Setup step.
# See next section for the documentation
# - name: Setup Node.js
# uses: actions/setup-node
- name: Run DevBird
uses: delinoio/devbird-action@main
with:
agent: ${{ inputs.agent }}
agent_model: ${{ inputs.agent_model }}
devbird_mode: ${{ inputs.devbird_mode }}
devbird_workflow_execution_token: ${{ inputs.devbird_workflow_execution_token }}
prompt: ${{ inputs.prompt }}
base_branch: ${{ inputs.base_branch }}
delino_access_token: ${{ secrets.DELINO_ACCESS_TOKEN }}
claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
openai_api_key: ${{ secrets.OPENAI_API_KEY }}
```
### 3. Customize the setup steps
The workflow includes a setup step that you should customize for your repository:
```yaml theme={null}
- name: Setup Node.js
uses: actions/setup-node
```
Replace these with your project's setup steps. The steps here should configure a complete development environment for the AI agent.
For example, the Delino monorepo includes steps for
* installing protoc for RPC definitions
* installing golang for backend servers
* installing nodejs for next.js apps
* fetching environment variables for development environment
### 4. Filter environment variables for security
**Security Best Practice**
Passing all environment variables to AI agents is not recommended. You should filter environment variables to only include those that are safe to expose.
Delino's official repositories use a filtering approach to ensure only safe environment variables are available during DevBird execution. Add a filtering step in your setup to restrict which environment variables the AI agent can access:
```bash theme={null}
# Filter environment variables in DevBird mode
if [ -n "${DEVBIRD:-}" ]; then
echo "DevBird mode detected - filtering environment variables to NEXT_PUBLIC_* and TEST_* only"
if [ -f ".env" ]; then
grep -E '^(NEXT_PUBLIC_|TEST_)' .env > .env.filtered || true
mv .env.filtered .env
fi
fi
```
This script filters the `.env` file to only include variables with these prefixes:
* **`NEXT_PUBLIC_`**: Variables that are meant to be publicly exposed (e.g., for Next.js client-side code)
* **`TEST_`**: Variables used for E2E testing, which have minimal security risk if leaked
The `DEVBIRD` environment variable (set to `1` in the workflow configuration) triggers this filtering behavior, ensuring your sensitive credentials remain protected.
You can customize the filtering pattern to match your project's naming conventions. The key is to only expose environment variables that are safe for the AI agent to access.
### 5. Configure `DELINO_ACCESS_TOKEN`
Create a new API key following the guide at [Creating API Keys](/core/api-keys/creation) and add it as a repository secret on GitHub settings.
### 6. Commit to your main branch
Commit the workflow file to your repository's main branch:
```bash theme={null}
git add .github/workflows/devbird.yml
git commit -m "Add DevBird workflow"
git push
```
## Understanding workflow execution
**Important: Workflow runs on the main branch**
For security reasons, the DevBird GitHub Action always executes on your repository's default branch (typically `main`). This means:
* The workflow runs from the main branch codebase
* GitHub Actions logs will show the workflow running on `main`
* This is by design to prevent security vulnerabilities
The `base_branch` parameter controls which branch DevBird uses as the base when creating new feature branches, but the workflow execution itself always happens on the default branch.
This security design prevents potential issues such as:
* Malicious workflow modifications in feature branches
* Unauthorized access to repository secrets
* Tampering with the DevBird workflow configuration
## Next steps
Once the workflow is set up, you can start using DevBird to automate development tasks. Learn how to trigger your first DevBird task in the [Creating your first PR](/devbird/getting-started/first-pr) guide.
# Prerequisites
Source: https://docs.delino.io/devbird/getting-started/prerequisites
Requirements to get started with DevBird
Before you begin using DevBird, ensure you have the following:
## Delino Account
You need either a **Delino Pro** or **Delino Team** account to use DevBird.
The pricing of DevBird is **\$0.01 per workflow execution, with a minimum charge of \$10 per month**.
Both plans offer the same features:
* **Pro**: Includes a 7-day free trial
* **Team**: Fixed monthly price regardless of team size
## GitHub Repository
DevBird requires a GitHub repository to work with. Both public and private repositories are supported.
You'll need to install the GitHub App and grant DevBird access to your repositories. See [Installing GitHub App](./github-app) for detailed instructions.
## Next steps
Once you have your Delino account and GitHub repository ready, proceed to [Installing GitHub App](./github-app) to connect them.
# What is DevBird?
Source: https://docs.delino.io/devbird/index
AI-powered automated development platform that creates and manages pull requests
DevBird is a fully automated development platform that uses AI coding agents to handle development tasks end-to-end. Instead of manually writing code, you describe what you need, and DevBird's AI agents create pull requests, respond to code reviews, and fix CI failures automatically.
## How it works
1. **Connect your repository** - Install the DevBird GitHub App
2. **Describe your task** - Tell DevBird what you want to build or fix
3. **AI creates PRs** - DevBird's AI agents write code and create pull requests
4. **Automatic management** - DevBird responds to reviews and fixes CI failures
5. **You review and merge** - Review the AI-generated code and merge when ready
## Key features
### Simple tasks
Perfect for straightforward development work like bug fixes, small features, or refactoring. DevBird creates one or more pull requests to complete your task.
### Composite tasks
For complex projects, DevBird breaks down your request into multiple coordinated tasks with AI-powered planning. Each task builds on previous work, creating a complete solution step by step.
### Automated PR management
* Responds to code review comments automatically
* Fixes failing CI checks without manual intervention
* Converts PRs to draft during updates to avoid confusion
* Posts task context as comments for reviewers
### Multiple AI agents
Choose from [supported AI coding agents](/devbird/getting-started/ai-agent).
## Use cases
* **Bug fixes** - Describe the bug and DevBird creates a fix
* **New features** - Request a feature and get a complete implementation
* **Refactoring** - Improve code quality with automated refactoring
* **Documentation** - Generate or update documentation automatically
* **Test coverage** - Add tests to improve code coverage
* **Complex projects** - Break down large projects into manageable tasks
## Getting started
Follow the setup guide to start using DevBird:
1. [Prerequisites](/devbird/getting-started/prerequisites) - What you need before starting
2. [Install GitHub App](/devbird/getting-started/github-app) - Connect DevBird to your GitHub repositories
3. [Set up workflow](/devbird/getting-started/github-workflow) - Add the DevBird workflow to your repository
4. [Configure AI agent](/devbird/getting-started/ai-agent) - Set up your preferred AI coding agent
5. [Create your first PR](/devbird/getting-started/first-pr) - Generate your first AI-powered pull request
# Configuring AI Reviewer
Source: https://docs.delino.io/devbird/reviewing-prs/ai-reviewer
Enable bot reviews and automated code quality checks
DevBird can automatically respond to reviews from bot accounts, enabling automated code quality workflows.
## What is Auto-Apply Bot Reviews?
DevBird can automatically respond to reviews from bot accounts. For detailed information about this setting including how to enable it, when to use it, and configuration options, see the [Auto-apply Bot Reviews](/devbird/settings#auto-apply-bot-reviews) documentation.
## How It Works
### Normal Review Workflow
**Without auto-apply:**
1. Bot submits review
2. Nothing happens (bot hasn't connected repository)
3. Review is ignored
**With auto-apply enabled:**
1. Bot submits review
2. DevBird detects it's a bot account
3. Automatically triggers update workflow
4. Uses GitHub App credentials
5. PR is updated based on bot feedback
### Bot Detection
DevBird identifies bots using GitHub's API:
* Checks reviewer's `type` field
* `type: "Bot"` = automated account
* `type: "User"` = human account
Common bot accounts:
* Dependabot
* Renovate
* CodeClimate
* Snyk
* Custom CI/CD bots
## Use Cases
For common use cases including code quality bots, security scanning, and dependency updates, see the [Auto-apply Bot Reviews use cases](/devbird/settings#auto-apply-bot-reviews) in the settings documentation.
## Configuration
### Team-Level Setting
Auto-apply is configured per team:
* All team members use same setting
* Applies to all connected repositories
* Can be toggled on/off anytime
### Per-Repository Behavior
Currently, the setting applies to all repositories in the team. Future versions may support per-repository configuration.
## Disabling Auto-Apply
For information about when and how to disable this feature, see [when to disable Auto-apply Bot Reviews](/devbird/settings#auto-apply-bot-reviews) in the settings documentation.
## Troubleshooting
For detailed troubleshooting of bot reviews and auto-apply issues, see the [AI Reviewer Troubleshooting](/devbird/troubleshooting/ai-reviewer) guide.
## Best Practices
For best practices and configuration recommendations, see the [Auto-apply Bot Reviews configuration tips](/devbird/settings#configuration-tips) in the settings documentation.
## Supported Bot Platforms
DevBird auto-apply works with any bot account recognized by GitHub:
**Dependency Management:**
* Dependabot
* Renovate
* Greenkeeper
**Code Quality:**
* CodeClimate
* SonarCloud
* Codacy
* DeepSource
**Custom Bots:**
* Any bot created with GitHub App
* Custom CI/CD bots
* Internal automation tools
## Limitations
### Current Limitations
1. **Team-level only:**
* Cannot configure per-repository
* All repos use team setting
2. **All-or-nothing:**
* Cannot select specific bots
* Either all bots or no bots
3. **No custom rules:**
* Cannot filter by bot type
* Cannot set conditions
### Future Enhancements
Planned features:
* Per-repository settings
* Bot allowlist/blocklist
* Conditional auto-apply rules
* Custom workflow templates
## Alternative: Manual Bot Review Handling
If auto-apply doesn't fit your workflow:
### Option 1: Disable Auto-Apply
* Turn off auto-apply
* Manually review bot feedback
* Use "Update PR" when needed
* More control, more manual work
### Option 2: Selective Application
* Keep auto-apply off
* Enable for specific tasks
* Manual trigger for others
* Balance automation and control
### Option 3: Apply Reviews from Other reviewers
You can also manually apply bot review feedback from other PRs using the Reflect command:
1. Copy the bot review comment link from another PR
2. Submit a review with "Request changes" on the current PR
3. Use the Reflect command with the comment URL
This allows you to selectively apply bot reviews without enabling auto-apply. For detailed instructions, see [Applying reviews from other PRs](/devbird/reviewing-prs#applying-reviews-from-other-prs).
## Next Steps
* [AI Reviewer Troubleshooting](/devbird/troubleshooting/ai-reviewer)
* [PR Review Process](/devbird/reviewing-prs)
* [Settings Configuration](/devbird/settings)
* [Unit Task Guide](/devbird/tasks/unit)
# How DevBird Handles PR Reviews
Source: https://docs.delino.io/devbird/reviewing-prs/index
Understand DevBird's automated pull request review and update workflow
DevBird automatically manages pull request reviews and updates, responding to feedback and fixing issues without manual intervention.
## The automated PR workflow
### 1. PR Creation
When DevBird creates a pull request:
* PR is opened for review
* Task link comment is added
* Task prompt comment is added (if enabled)
* CI checks begin running
### 2. Code Review
Team members review the PR normally:
* Leave review comments
* Request changes
* Approve changes
### 3. Automatic Response
When a review is submitted, DevBird:
* Detects the review via GitHub webhook
* Converts PR to draft status (except for simple approvals)
* Triggers a workflow to address the feedback
* AI agent analyzes the review and makes changes
* Pushes updates to the PR branch
* CI checks run again
### 4. CI Monitoring
DevBird watches CI check status:
* When all checks complete
* If any checks fail
* Automatically triggers fix workflow
* AI agent investigates and fixes failures
* Updates are pushed to the PR
### 5. Ready for Merge
When everything passes:
* All CI checks pass
* All review feedback addressed
* PR is automatically undrafted (if enabled)
* Ready for final approval and merge
## PR comments
### Task Link Comment
Always added to every DevBird PR:
```markdown theme={null}
🤖 This pull request has been linked to DevBird Task #123
View the task details and manage the automated development
workflow in DevBird.
```
Provides:
* Link to the DevBird task
* Task ID reference
* Context for reviewers
### Task Prompt Comment
Optional, enabled by default. Shows the original task prompt in PR comments to provide context for reviewers.
For details about this feature including benefits and how to configure it, see [Enable Prompt Comments](/devbird/settings#enable-prompt-comments) in the settings documentation.
## Review types and behavior
### Changes Requested
When reviewer requests changes:
1. PR converts to draft
2. DevBird workflow triggered
3. AI analyzes review comments
4. Changes are made and pushed
5. PR remains draft until CI passes
### Comments Only
When reviewer adds comments (not requesting changes):
1. PR converts to draft
2. DevBird workflow triggered
3. AI addresses comments
4. Updates pushed to PR
5. PR remains draft until CI passes
### Approvals
When reviewer approves without comments:
1. PR stays as-is (not converted to draft)
2. No workflow triggered
3. PR ready for merge (if CI passes)
### Bot Reviews
When a bot account submits a review, behavior depends on the "Auto-apply Bot Reviews" setting. See [Settings](/devbird/settings) for details.
## Reviewer permissions
For security, DevBird verifies that reviewers have appropriate permissions before triggering workflows:
### Write Access Requirement
**For human reviewers:**
* Must have **Write** (Push) or **Admin** access to the repository
* Verified via GitHub API permission check
* Reviews from users without write access are silently ignored
* All permission checks are logged for security auditing
**For bot reviewers:**
* Exempt from permission checks when "Auto-apply Bot Reviews" is enabled
* Use GitHub App installation token for authentication
* Bypasses individual permission requirements
### Why write access is required
This security measure prevents:
* Unauthorized users from triggering workflows via PR reviews
* Potential abuse of compute resources
* Unauthorized code execution in your workflows
### Troubleshooting permission issues
If your reviews aren't triggering workflows:
1. Verify you have **Write** or **Admin** access to the repository
2. Check that you've connected the repository in DevBird
3. Ensure the repository has DevBird webhook configured
4. Review webhook delivery logs for permission errors
**Note**: Read-only collaborators cannot trigger DevBird workflows through PR reviews, even if they've connected the repository.
## Draft status during updates
DevBird converts PRs to draft during automated updates to:
* Signal work is in progress
* Prevent accidental merges during changes
* Avoid confusing reviewers
* Indicate AI is actively working
**Exception**: Simple approvals don't trigger draft conversion.
## Automatic CI fixes
When CI checks fail:
### Detection
DevBird monitors:
* `check_run` webhooks
* `check_suite` webhooks
* Waits for all checks to complete
* Identifies failing checks
### Fix Workflow
If failures detected:
1. Creates fix workflow execution
2. Converts PR to draft
3. Generates detailed fix prompt with:
* Original task prompt
* List of failing checks
* Links to check details
4. AI investigates failures using GitHub CLI
5. Fixes are made and pushed
6. CI runs again
### Rate Limiting
To prevent excessive fix attempts:
* Maximum 1 fix attempt per commit
* Tracked by commit SHA
* New commits allow new fix attempts
## Auto-undraft feature
When enabled (default), DevBird automatically converts draft PRs to ready-for-review when all CI checks pass.
For details about this feature including when to enable/disable it and configuration options, see [Auto-undraft PR](/devbird/settings#auto-undraft-pr) in the settings documentation.
## GitHub Ruleset recommendations
To optimize DevBird's automated workflow, we recommend configuring GitHub Rulesets to protect your repository while allowing DevBird to work efficiently.
### Recommended ruleset configuration
**Branch protection rules:**
* **Require pull request reviews** - Ensure human oversight of AI-generated code
* **Require status checks to pass** - Enforce CI validation before merging
* **Allow force pushes: Enable for DevBird bot** - Let DevBird clean up commit history after addressing reviews
* **Allow deletions: Disable** - Protect branches from accidental deletion
**Why allow force pushes for DevBird:**
When DevBird addresses review feedback or fixes CI failures, it may need to force push to maintain a clean commit history. This is safe because:
* Only the DevBird bot account has this permission
* Changes still go through PR review
* CI checks must still pass
* Human approval required for merge
**Setting up the ruleset:**
1. Go to your repository settings
2. Navigate to Rules → Rulesets
3. Create a new ruleset for your target branches (e.g., `main`, `develop`)
4. Configure branch protections as above
5. Under "Bypass list," add the DevBird bot account for force push permissions
This configuration ensures code quality while allowing DevBird to manage PRs efficiently without manual intervention.
## Best practices
### For Reviewers
**Be specific in feedback:**
```
Please add error handling for the null case on line 45
```
Better than:
```
Needs error handling
```
**Reference specific code:**
```
In UserService.authenticateUser(), add rate limiting
to prevent brute force attacks
```
**Provide context:**
```
This approach won't work with our existing session
management. Please use the SessionManager class instead.
```
### For PR Authors
**Monitor automated updates:**
* Check that DevBird addressed your feedback
* Review changes made by AI
* Add manual updates if needed
**Collaborate with AI:**
* Request updates through DevBird
* Let AI handle repetitive fixes
* Make final manual adjustments
**Keep PRs focused:**
* Single responsibility per PR
* Easier for AI to maintain
* Faster review cycles
## Manual PR updates
You can also manually request PR updates:
1. Go to DevBird task details
2. Find the PR you want to update
3. Click **Update PR**
4. Enter update instructions
5. DevBird converts PR to draft and makes changes
Use manual updates when:
* Review feedback is complex
* Need additional features
* Want to refine the implementation
## Applying reviews from other reviewers
You can apply review feedback from other pull requests using the Reflect command:
1. Find the review comment you want to apply.
2. Copy the comment's direct link (e.g., `https://github.com/delinoio/devbird-example/pull/123#issuecomment-337041341`)
3. On the current PR, submit a review with "Request changes"
4. In the review message, use: `Reflect https://github.com/delinoio/devbird-example/pull/123#issuecomment-337041341`
5. DevBird will analyze the linked review comment and apply those changes to the current PR
This is useful when:
* Applying reviews from other people
## Troubleshooting
For common PR review issues and solutions, see the [PR Review Troubleshooting](/devbird/troubleshooting/pr-reviews) guide.
## Next steps
* [PR Review Troubleshooting](/devbird/troubleshooting/pr-reviews)
* Configure [DevBird Settings](/devbird/settings)
* Learn about [AI Reviewers](/devbird/reviewing-prs/ai-reviewer)
* Troubleshoot [Unit Tasks](/devbird/troubleshooting/unit-task)
# Settings
Source: https://docs.delino.io/devbird/settings/index
Configure DevBird behavior for your tenant
DevBird provides several settings to control how it handles tasks, PRs, and reviews. Settings are configured at the tenant level (your team or user account) and apply to all repositories under that tenant.
## Accessing Settings
1. Go to [Delino Dashboard](https://app.delino.io)
2. Navigate to Settings page
3. Configure settings as needed
4. Changes save automatically and apply to all repositories
## Available Settings
### Auto-apply Bot Reviews
**Default**: Disabled
Controls whether DevBird automatically triggers workflows when bot accounts submit PR reviews.
**When enabled:**
* Workflows trigger automatically on bot reviews
* Uses GitHub App installation tokens
* Bots don't need to connect the repository
* All attempts are logged for debugging
**Use cases:**
* AI code review tools (Claude Code, Cursor, GitHub Copilot)
* AI-powered PR analysis and suggestions
* Automated code quality assistants
* AI pair programming tools
**When to enable:**
* You have trusted bot integrations
* You want fully automated workflows
* You're using automated code review tools
**When to disable:**
* You want manual control over bot-triggered workflows
* You're concerned about excessive workflow runs
* You prefer reviewing bot suggestions first
### Enable Prompt Comments
**Default**: Enabled
Controls whether DevBird posts the full task prompt as a PR comment.
**When enabled:**
* Posts complete task prompt to PR comments
* Provides full context to reviewers
* Creates comprehensive audit trail
* Makes task requirements transparent
**When disabled:**
* Only posts task link comment
* Cleaner PR comment section
* Reduces comment noise
* Reviewers access details via link
**Best for enabling:**
* Teams who want inline context
* Compliance/audit requirements
* Transparent task tracking
* Quick reference without clicking links
**Best for disabling:**
* Teams preferring minimal PR comments
* Projects with many automated tasks
* When task details are sensitive
### Auto-undraft PR
**Default**: Enabled
**Status**: **TEMPORARILY DISABLED** ⚠️
This feature is currently disabled globally due to a bug and is under development. The toggle appears disabled in the UI with a warning message.
Controls whether DevBird automatically converts draft PRs to ready-for-review when CI passes.
**When enabled (after re-enablement):**
* Automatically marks PR ready when checks pass
* Signals completion to team
* Reduces manual workflow steps
* Enables automated review requests
**When disabled:**
* PRs remain in draft after CI passes
* Manual conversion required
* Additional quality control gate
* Gives time for self-review
**Best for enabling:**
* Fast-moving teams
* High confidence in CI/CD
* Automated workflows
* Trust in AI agent output
**Best for disabling:**
* Teams wanting manual review gates
* Additional quality assurance needed
* Learning/training environments
* Complex PRs requiring verification
**Current Behavior**: All PRs will remain in draft status even when CI passes until this feature is re-enabled.
### Default Planning Agent & Model
**Purpose**: Configure default AI agent and model for CompositeTask planning phase
These settings control which AI agent and model are used when DevBird generates task graphs for composite tasks.
**Planning Agent Options:**
* `claude_code` - Claude Code agent (recommended)
* `opencode` - OpenCode agent
* `crush_cli` - Crush CLI agent
* `codex_cli` - Codex CLI agent
* `gemini_cli` - Gemini CLI agent
* `github_copilot_cli` - GitHub Copilot CLI agent
**Planning Model Options:**
* Varies by agent (e.g., `sonnet`, `opus`, `haiku` for Claude Code)
**When set:**
* New composite tasks use these defaults for AI planning
* Generates task breakdown and dependency graph
* Creates execution plan
**When not set:**
* System defaults are used
**Use cases:**
* Choose more powerful models for complex project planning
* Select faster/cheaper models for simple decomposition
* Match agent capabilities to your planning needs
### Default Execution Agent & Model
**Purpose**: Configure default AI agent and model for task execution
These settings control which AI agent and model are used when:
* Creating and executing unit tasks
* Executing individual nodes in composite task graphs
**Execution Agent Options:**
Same as planning agent options above.
**Execution Model Options:**
Varies by agent.
**When set:**
* Unit tasks use these defaults
* Composite task nodes use these defaults
* Actual code writing and PR creation uses these
**When not set:**
* System defaults are used
**Use cases:**
* Different agent for planning vs. execution (e.g., powerful planner, fast executor)
* Balance cost and quality across workflow phases
* Optimize for execution speed or quality
### Default Composite Task Auto-Approval
**Default**: Disabled
Controls whether newly created composite tasks have auto-approval enabled by default.
**When enabled:**
* New composite tasks are created with auto-approval turned on
* After planning completes, ecution starts automatically
* Ready nodes are automatically approved without manual review
* Full workflow automation from creation to completion
**When disabled:**
* New composite tasks require manual execution start
* Each ready node requires manual approval
* More control over task progression
**What happens with auto-approval:**
1. You create a composite task
2. AI planning completes automatically
3. **Execution starts automatically** (no "Start Execution" click needed)
4. **Ready nodes auto-approve** (no manual approval needed)
5. Tasks complete without any manual intervention
**Note**: This setting only affects NEW composite tasks at creation time. You can still manually toggle auto-approval on individual composite tasks after they're created.
**Best for enabling:**
* Trusted workflows
* Repetitive tasks
* High confidence in AI planning
* Want hands-off automation
**Best for disabling:**
* Want to review plans before execution
* Need to modify prompts before running
* Careful control over task progression
* Learning/evaluating DevBird
## Configuration Tips
### Recommended for Most Teams
```
Auto-apply Bot Reviews: Disabled
Enable Prompt Comments: Enabled
Auto-undraft PR: Enabled
```
This provides good transparency while maintaining control over bot-triggered workflows.
### For High-Automation Teams
```
Auto-apply Bot Reviews: Enabled
Enable Prompt Comments: Disabled
Auto-undraft PR: Enabled
```
Maximizes automation and reduces manual intervention.
### For Cautious Teams
```
Auto-apply Bot Reviews: Disabled
Enable Prompt Comments: Enabled
Auto-undraft PR: Disabled
```
Provides maximum control and review opportunities at each step.
## Troubleshooting
### Settings not saving
**Check:**
1. Verify you have tenant admin permissions
2. Refresh the page and try again
3. Check browser console for errors
4. Contact [support@delino.io](mailto:support@delino.io)
### Settings not taking effect
**Verify:**
1. Settings page shows your changes
2. Wait a few minutes for propagation
3. Test with a new task/PR (not existing ones)
4. Check GitHub App permissions are current
### Bot reviews not triggering workflows
**When "Auto-apply Bot Reviews" is enabled:**
1. Verify bot account exists in your organization
2. Check GitHub webhook deliveries for errors
3. Ensure bot has correct permissions
4. Review workflow logs for failures
**When disabled:**
* This is expected behavior
* Enable the setting if you want automation
## Next Steps
* [Create your first task](/devbird/tasks)
* [Configure AI agents](/devbird/ai-agents/claude-code)
* [Review PRs efficiently](/devbird/reviewing-prs)
* [Troubleshoot common issues](/devbird/troubleshooting/unit-task)
# Composite Tasks
Source: https://docs.delino.io/devbird/tasks/composite/index
Break down complex projects into AI-planned coordinated tasks
Composite tasks use AI to break down complex projects into multiple coordinated steps. DevBird creates a task graph showing dependencies and execution order, allowing parallel work while ensuring tasks build on each other correctly.
## How composite tasks work
### 1. AI Planning Phase
When you create a composite task:
* DevBird analyzes your request
* AI generates a task graph (DAG structure)
* Tasks are organized with dependencies
* Plan is saved for your review
**Simple tasks can have a single node**: For straightforward requests that don't require breaking down into multiple steps, the AI may generate a task graph with just one node. This is normal and expected for tasks that are simple enough to be completed in a single execution.
Status: **Planning**
### 2. Review and Start
After planning completes:
* View the task graph visualization
* See all tasks and their dependencies
* Review the execution plan
* **If auto-approval is disabled**: Click **Start Execution** to begin
* **If auto-approval is enabled**: Execution starts automatically
Status: **Pending** → **In Progress**
**Auto-Start Behavior**:
* When `auto_approval_enabled` is true, execution starts automatically after planning
* No "Start Execution" button click needed
* Initial nodes (without dependencies) are marked as "ready" immediately
* Saves time and enables fully automated workflows
* Can be configured via tenant settings or per-task toggle
### 3. Task Execution
Tasks execute based on dependencies:
* Initial tasks (no dependencies) become **Ready**
* You approve each ready task
* Approved tasks spawn unit tasks
* Tasks run in parallel when possible
* New tasks become ready as dependencies complete
### 4. Completion
When all tasks finish:
* Composite task status: **Completed**
* All pull requests are created
## Creating a composite task
1. Go to your DevBird dashboard
2. Select your repository
3. Enter your complex project description
4. **Check "Create as Composite Task"**
5. (Optional) Configure defaults for all tasks:
* AI Agent: Default agent for all nodes
* Model Version: Default model for all nodes
* Base Branch: Branch for all tasks
6. Click **Create Task**
## Task graph structure
The task graph shows:
### Nodes
Each node represents a task to be completed:
* **Pending** (gray) - Waiting for dependencies
* **Ready** (blue) - Dependencies met, awaiting approval
* **Approved** (yellow) - Approved, about to start
* **In Progress** (orange) - Currently executing
* **Completed** (green) - Successfully finished
* **Failed** (red) - Encountered an error
* **Blocked** (dark gray) - Cannot proceed due to failed dependency
### Edges
Arrows show dependencies:
* Task A → Task B means B depends on A
* Task B starts only after Task A completes
### Parallel execution
Tasks without dependencies on each other run in parallel:
```
Task A
/ \
Task B Task C (B and C run in parallel)
\ /
Task D (D waits for both B and C)
```
## Approving tasks
When a task becomes ready:
1. Review the task's auto-generated prompt
2. (Optional) Modify the prompt before approving
3. Click **Approve** to start execution
4. Task spawns a unit task and begins work
### Auto-approval mode
Enable auto-approval to run tasks automatically:
1. Go to composite task details
2. Enable **Auto-Approval**
3. Ready tasks are automatically approved and executed
4. No manual intervention required
**Two-Level Auto-Approval:**
1. **Tenant-Level Default** (Settings):
* Set "Default Composite Task Auto-Approval" in tenant settings
* Determines auto-approval status for NEW composite tasks
* Existing tasks are not affected
2. **Per-Task Toggle** (Task Details):
* Enable/disable for individual composite tasks
* Overrides the tenant default for that specific task
* Can be changed at any time
**What Auto-Approval Enables:**
1. **Auto-Start Execution** (after planning completes):
* No need to click "Start Execution"
* Automatically transitions from "pending" to "in\_progress"
* Initial nodes become "ready" immediately
2. **Auto-Approve Ready Nodes**:
* Ready nodes automatically spawn unit tasks
* No manual approval required
* Continuous task progression
Use auto-approval when:
* You trust the AI-generated plan
* Tasks are well-defined and low-risk
* You want continuous progress without manual steps
* Running repetitive or batch operations
* Full automation from creation to completion
Disable auto-approval when:
* You want to review each task before execution
* Tasks require careful sequencing
* You want to modify prompts before execution
* Learning or evaluating task plans
* Complex projects requiring oversight
## Managing composite tasks
### Task details page
View comprehensive information:
**Overview section:**
* Title and description
* Repository and branch
* Progress (X/Y tasks completed)
* Current status
* Creation time
**Task graph visualization:**
* Interactive diagram of all tasks
* Color-coded status indicators
* Click nodes to see details
* View dependencies
**Ready for approval:**
* List of tasks ready to execute
* Option to modify prompts
* Approve or reject buttons
**Active tasks:**
* Currently executing tasks
* Links to spawned unit tasks
* Real-time status
**Completed tasks:**
* Finished tasks
* Links to pull requests
* Merge status
**Failed/blocked tasks:**
* Failed tasks with error details
* Retry options
* Blocked tasks showing required dependencies
### Editing task prompts
You can edit task prompts before execution:
**During approval:**
1. Task becomes ready
2. Review the AI-generated prompt
3. Click **Edit Prompt**
4. Make your changes
5. Approve to execute with modified prompt
**Before approval:**
1. Go to task graph visualization
2. Click on a task node (must be pending, ready, or blocked)
3. Edit the prompt and title
4. Save changes
5. Approve when ready
**Note**: You cannot edit prompts for tasks that are approved, in progress, completed, or failed.
### Retrying failed tasks
If a task fails:
1. Review the error details
2. (Optional) Edit the task prompt
3. Click **Retry**
4. A new unit task is created with the same (or updated) configuration
### Syncing composite tasks
The sync feature checks all tasks and updates statuses:
1. Go to composite task details
2. Click **Sync Composite Task**
3. DevBird checks all tasks and PRs:
* Updates PR merge statuses from GitHub
* Marks completed tasks when PRs are merged
* Recalculates node readiness
* Triggers auto-approval if enabled
* Updates composite task progress
Returns:
* Tasks updated count
* Nodes updated count
* PRs synced count
* Workflows triggered count
## Task graph best practices
### How AI creates the plan
DevBird uses advanced prompting to create efficient task graphs:
**Planning priorities:**
1. **Minimize rebasing** - Structure for parallel execution
2. **CI/Infrastructure first** - Set up testing before features
3. **Independent code paths** - Tasks touch different files
4. **Clear boundaries** - Define interfaces early
**Task ordering:**
* Phase 1: CI/Infrastructure (no dependencies)
* Phase 2: Database/Storage setup
* Phase 3: Core contracts (APIs, models)
* Phase 4: Parallel features
* Phase 5: Integration
* Phase 6: Polish (UI, performance, docs)
**Graph structure:**
* Wide and shallow (more parallel, fewer sequential)
* Each task represents meaningful progress
### Writing effective composite task prompts
**Include comprehensive context:**
```
Build a complete e-commerce checkout system including:
- Shopping cart with session persistence
- Payment processing with Stripe integration
- Order confirmation emails
- Admin order management dashboard
- Inventory updates after purchase
```
**Specify technical requirements:**
```
Migrate to microservices architecture using:
- Docker containers for each service
- API Gateway with Kong
- Event bus with RabbitMQ
- Shared PostgreSQL database
- CI/CD with GitHub Actions
```
**Reference documentation:**
```
Implement authentication following our architecture:
- Reference: @docs/auth-architecture.md
- Use our existing JWT library
- Follow security guidelines in @SECURITY.md
```
## Deleting composite tasks
Deleting a composite task:
1. Cancels all incomplete unit tasks
2. Blocks all pending/ready task nodes
3. Cancels running GitHub Actions workflows
4. Removes the composite task
**Note**: This action cannot be undone. Unit tasks are cancelled but preserved for history.
## Example composite task
**Prompt:**
```
Build a user authentication system with email verification and OAuth
```
**Generated task graph:**
```
1. Setup CI/CD pipeline
↓
2. Create database schema and migrations
↓
├→ 3. Implement email authentication
│ ├→ User registration
│ ├→ Email verification
│ └→ Password reset
│
├→ 4. Implement OAuth integration
│ ├→ Google OAuth
│ ├→ GitHub OAuth
│ └→ OAuth callback handling
│
└→ 5. Build frontend components
├→ Login/register forms
├→ OAuth buttons
└→ Email verification UI
↓
6. Integration tests and documentation
```
Tasks 3, 4, and 5 run in parallel after task 2 completes.
## Benefits of composite tasks
### Coordinated execution
* Tasks build on each other
* Dependencies ensure correct order
* Parallel work speeds completion
### AI-powered planning
* Optimal task breakdown
* Smart dependency management
* Efficient parallelization
### Flexibility
* Modify prompts before execution
* Retry failed tasks
* Enable/disable auto-approval
### Visibility
* See entire project plan upfront
* Track progress across all tasks
* Understand dependencies
### Batch processing with consistent prompts
Composite tasks excel at applying the same logic across multiple independent items, creating separate PRs for each one. This is ideal for:
**Translation and localization:**
```
Review all DevBird documentation pages one by one and fix awkward translations.
Check each supported language individually.
Create one PR per page. Only create PRs if translations need fixing.
```
DevBird will:
* Plan separate tasks for each documentation page
* Apply the same review logic to each language version
* Create individual PRs only when improvements are needed
* Process pages in parallel for faster completion
**Pro tip**: Creating one task per page is highly effective because:
* **Parallelization**: Multiple pages are processed simultaneously
* **Focus**: Each AI agent works on a single page, preventing the common issue of AI agents forgetting their tasks midway through complex work
* **Isolation**: Problems in one page don't affect others
Example prompt:
```
Make the translation of each DevBird page smooth and natural.
Create one task per page. Each task should handle one page.
Each task should not create a PR if there are no translation issues.
```
**Codebase-wide refactoring:**
```
Update all API endpoints to use the new authentication middleware.
Create one PR per endpoint group.
Ensure backward compatibility in each change.
```
## When not to use composite tasks
Use unit tasks instead when:
* Task is straightforward and single-purpose
* No dependencies on other work
* Quick fix or small change
* One pull request is sufficient
## Troubleshooting
See the [Composite Task Troubleshooting](/devbird/troubleshooting/composite-task) guide for common issues.
## Next steps
* Learn about [Unit Tasks](/devbird/tasks/unit)
* Understand [PR Review Process](/devbird/reviewing-prs)
* Configure [AI Agents](/devbird/ai-agents/claude-code)
# Understanding Tasks
Source: https://docs.delino.io/devbird/tasks/index
Learn about the two types of tasks in DevBird and when to use each
DevBird offers two types of tasks to handle different development scenarios: **Unit Tasks** for straightforward work and **Composite Tasks** for complex projects.
## Unit Tasks
Unit tasks are perfect for single, well-defined development tasks. When you create a unit task, DevBird's AI agent:
1. Analyzes your request
2. Writes the necessary code
3. Creates one or more pull requests
4. Responds to code reviews automatically
5. Fixes any CI failures
### When to use unit tasks
* **Bug fixes** - Fix a specific bug or issue
* **Small features** - Add a single, straightforward feature
* **Refactoring** - Improve code structure in a focused area
* **Documentation** - Update or create documentation
* **Quick updates** - Make targeted changes to existing code
### Example unit tasks
```
Fix the authentication bug where users can't log in with OAuth
```
```
Add input validation to the user registration form
```
```
Refactor the payment processing service to use the new API
```
## Composite Tasks
Composite tasks are designed for complex projects that require multiple coordinated steps. DevBird uses AI to break down your request into a task graph (DAG structure) where tasks can run in parallel or sequence based on dependencies.
### How composite tasks work
1. **AI Planning** - DevBird analyzes your request and creates a task graph
2. **Review Plan** - You see the proposed tasks and their dependencies
3. **Start Execution** - You approve the plan and start execution
4. **Sequential Execution** - Tasks become ready as dependencies complete
5. **Auto-approval (Optional)** - Enable auto-approval to run tasks automatically
6. **Coordinated Completion** - All tasks work together to complete your project
### When to use composite tasks
* **Large features** - Features that require multiple coordinated changes
* **System refactoring** - Major code restructure across multiple modules
* **New projects** - Setting up a new service or application from scratch
* **Complex integrations** - Integrating multiple systems or APIs
* **Multi-step migrations** - Database or infrastructure migrations
### Example composite tasks
```
Build a complete user authentication system with email verification,
password reset, and OAuth integration
```
```
Migrate our REST API to GraphQL, including schema design, resolvers,
and updating all client code
```
```
Set up CI/CD pipeline with automated testing, Docker deployment,
and monitoring
```
## Task Configuration
Both task types support optional configuration:
### Repository selection
Choose which repository the AI should work on. You can only select repositories where you've installed the DevBird GitHub App.
### AI Agent selection (Optional)
Choose which AI coding agent to use. See [available AI agents](/devbird/getting-started/ai-agent) for the full list.
If not specified, DevBird uses your team's default agent.
### Model version (Optional)
Specify the AI model version (e.g., "sonnet", "gpt-4"). If not specified, the agent's default model is used.
### Base branch (Optional)
Specify which branch to use as the base for the task. Defaults to your repository's default branch (usually `main` or `master`).
## Task Status
Tasks progress through different statuses:
* **Pending** - Task created but not yet started
* **In Progress** - AI agent is working on the task
* **Completed** - All work finished and PRs created
* **Failed** - Task encountered an error
* **Cancelled** - Task was cancelled by user
## Pull Requests
Each task can create multiple pull requests. DevBird automatically:
* Creates descriptive PR titles and descriptions
* Links PRs back to the task
* Posts the task prompt as a comment (configurable)
* Converts PRs to draft during automated updates
* Responds to code review comments
* Fixes failing CI checks
## Next steps
* Learn about [Unit Tasks](/devbird/tasks/unit)
* Learn about [Composite Tasks](/devbird/tasks/composite)
* See [Creating your first PR](/devbird/getting-started/first-pr)
# Unit Tasks
Source: https://docs.delino.io/devbird/tasks/unit/index
Create and manage single-focus development tasks with AI automation
Unit tasks are DevBird's building blocks for straightforward development work. Each unit task focuses on a single objective and can generate multiple pull requests to complete it.
## Creating a unit task
1. Navigate to your DevBird dashboard
2. Select your repository from the dropdown
3. Enter your task description in the prompt field
4. **Leave "Create as Composite Task" unchecked** for unit tasks
5. (Optional) Configure advanced settings:
* AI Agent: Choose your preferred AI coding agent
* Model Version: Specify the model version
* Base Branch: Choose the branch to work from
6. Click **Create Task**
## Task lifecycle
### 1. Pending
Your task is created and queued for execution. DevBird prepares to trigger the GitHub Actions workflow.
### 2. In Progress
The AI agent is actively working on your task:
* Analyzing your requirements
* Writing code
* Creating pull requests
* Running tests
**Detailed Status**: When a task is in progress, DevBird shows detailed information about what's currently happening:
* "Creating initial implementation..." - AI is writing the first version
* "Addressing PR review feedback..." - Responding to review comments
* "Fixing CI failures..." - Attempting to fix failing tests
* "Updating pull request..." - Making requested changes
This gives you real-time visibility into the current workflow execution phase.
### 3. Completed
The task is marked complete when all pull requests are merged. This means:
* All code changes have been reviewed and approved
* All PRs have been merged to their target branches
* The task objectives have been successfully implemented
### 4. Failed
The task encountered an error. Common reasons:
* GitHub Actions workflow failed
* Invalid configuration
* AI agent encountered an issue
You can retry failed tasks from the task details page.
## Task details page
The task details page shows:
### Task overview
* Task title (automatically generated from your prompt)
* Original prompt
* Repository and branch information
* Current status
* Creation timestamp
### Pull requests
All PRs created for this task:
* PR title and number
* Status (open/closed/merged)
* CI check results
* Review comment count
* Links to GitHub
### Workflow executions
History of all workflow runs for this task, including:
**Direct task workflows:**
* Task creation - Initial implementation
* Task retries - Retry after failure
**PR-related workflows:**
* PR updates - Manual update requests
* PR reviews - Responses to review feedback
* PR CI fixes - Automatic fixes for failing checks
**Details shown:**
* Execution status (pending/in\_progress/completed/failed)
* Workflow type
* Timestamps (created, started, completed)
* GitHub Actions run link (when available)
* Retry button for failed executions
## Managing pull requests
### Automatic PR comments
When a PR is created, DevBird adds two types of comments:
**Task link comment** (always added):
* Links back to the DevBird task
* Provides context for reviewers
**Task prompt comment** (optional, enabled by default):
* Shows the original task prompt
* Helps reviewers understand the AI's instructions
* Can be disabled in [Settings](/devbird/settings)
### PR workflow
1. **PR Creation** - AI creates PR and opens it for review
2. **Draft Status** - PR is converted to draft during automated updates
3. **Code Review** - Team members review the changes
4. **AI Responds** - DevBird automatically responds to review comments
5. **CI Checks** - Automated tests run
6. **CI Fixes** - DevBird fixes failing checks automatically
7. **Ready to Merge** - PR is undrafted when all checks pass
## Updating a pull request
You can manually request updates to any PR:
1. Go to the task details page
2. Find the PR you want to update
3. Click **Update PR**
4. Enter your update instructions
5. DevBird converts the PR to draft and makes the changes
## Retrying a task
If a task fails, you can retry it:
1. Go to the task details page
2. Click **Retry Task** in the workflow executions section
3. The task will re-execute with the same configuration
## Syncing task status
Use the sync feature to refresh task status from GitHub:
1. Go to the task details page
2. Click **Sync Task** in the Debug menu
3. DevBird checks all PRs and updates the task status automatically:
* **All PRs merged** → Task marked as completed
* **All PRs closed without merge** → Task marked as failed
* **PRs still open** → Status remains in progress
## Deleting a task
Deleting a task:
* Closes all open pull requests
* Cancels any running workflows
* Removes the task from your dashboard
**Note**: This action cannot be undone.
## Best practices
### Write clear prompts
Be specific about what you want:
**Good prompts:**
```
Fix the null pointer exception in UserService.java when email is missing
```
```
Add rate limiting to the /api/auth endpoint with 10 requests per minute
```
```
Update the user profile page to show avatar upload with preview
```
**Avoid vague prompts:**
```
Fix the bug
```
```
Make it better
```
```
Update the code
```
### Include context
Reference specific files, functions, or error messages:
```
Fix the CORS error on line 45 of server.js when calling from localhost:3000
```
### Use file references
Include file paths with `@` for better AI understanding:
```
Refactor @src/services/payment.ts to use the new PaymentProcessor interface
```
### Specify requirements
Include technical requirements or constraints:
```
Add user authentication using JWT tokens with 24-hour expiration,
stored in httpOnly cookies
```
### Break down large tasks
For complex work, consider using [Composite Tasks](/devbird/tasks/composite) or creating multiple unit tasks.
## Troubleshooting
See the [Unit Task Troubleshooting](/devbird/troubleshooting/unit-task) guide for common issues and solutions.
## Next steps
* Learn about [Composite Tasks](/devbird/tasks/composite)
* Understand [PR Review Process](/devbird/reviewing-prs)
* Configure [AI Agents](/devbird/ai-agents/claude-code)
# AI Reviewer Troubleshooting
Source: https://docs.delino.io/devbird/troubleshooting/ai-reviewer
Troubleshoot bot reviews and auto-apply issues in DevBird
This document is still under review. The content may be inaccurate or
outdated.
## Bot Reviews Not Triggering Workflows
**Symptoms:**
* Bot submits review
* No workflow triggered
* PR not updated
**Common Cause:**
Auto-apply bot reviews may be disabled. See [troubleshooting bot reviews](/devbird/settings#bot-reviews-not-triggering-workflows) in the settings documentation for complete troubleshooting steps.
**Quick Solutions:**
**Check bot account type:**
1. Go to bot's GitHub profile
2. Verify it shows "Bot" badge
3. Check via API: `https://api.github.com/users/{bot-username}`
4. Look for `"type": "Bot"` in response
**Manual trigger alternative:**
* Use "Update PR" feature
* Manually apply bot feedback
* Trigger workflow explicitly
## Too Many Bot Workflows
**Symptoms:**
* Bots triggering too many workflows
* High costs
* Excessive automation
* Workflow queue backlog
**Causes:**
* Multiple bots reviewing same PR
* Bots reviewing too frequently
* Auto-apply enabled with many bots
* Bots leaving multiple comments
**Solutions:**
**Disable auto-apply:**
* Temporarily turn off the feature
* Manually review bot feedback
* Selectively apply changes
**Configure bots to review less:**
* Adjust bot settings in repository
* Reduce review frequency
* Filter what bots review
* Limit bot triggers
**Monitor usage:**
* Check costs
* Review workflow execution history
* Identify which bots trigger most workflows
* Adjust bot configuration accordingly
**Cost optimization:**
```
Each bot review = 1 workflow execution
1 execution = $0.03
Multiple bots × frequent reviews = high costs
```
## Bot Feedback Not Applied Correctly
**Symptoms:**
* Workflow runs but doesn't fix issues
* Bot re-reviews with same feedback
* Changes don't match bot requests
* AI misunderstands bot comments
**Causes:**
* Bot feedback unclear for AI
* Complex fixes beyond AI capability
* Conflicting feedback from multiple bots
* Bot using uncommon terminology
**Solutions:**
**Review workflow logs:**
1. Check what AI agent attempted
2. See if it understood bot feedback
3. Identify where it failed
4. Look for error messages
**Manual intervention:**
1. Disable auto-apply temporarily
2. Manually fix based on bot feedback
3. Push updates to PR
4. Re-enable auto-apply after resolution
**Improve bot feedback:**
* Configure bots to give specific guidance
* Use structured feedback formats
* Limit scope of bot reviews
* Ensure bots provide file paths and line numbers
**Example of good bot feedback:**
```
In src/utils/auth.js:45, change:
if (user == null)
to:
if (user === null)
Use strict equality for null checks.
```
**Example of poor bot feedback:**
```
Fix the equality checks
```
## Bots Not Detected
**Symptoms:**
* Bot has "Bot" badge on GitHub
* Auto-apply enabled
* Reviews still don't trigger workflows
* Bot appears to be ignored
**Causes:**
* Bot account not properly configured
* GitHub API inconsistency
* Webhook not receiving bot reviews
* Bot review format not recognized
**Solutions:**
**Verify bot configuration:**
1. Check bot is properly installed on repository
2. Verify bot has review permissions
3. Confirm bot is active
**Test with manual trigger:**
1. Have bot submit review
2. Manually use "Update PR" feature
3. Paste bot feedback
4. See if AI can handle it
**Check webhook logs:**
1. Repository settings → Webhooks
2. Find DevBird webhook
3. Check for bot review events
4. Verify event payload contains bot info
**Alternative solution:**
* Contact DevBird support
* Provide bot account details
* Share webhook logs
* Request investigation
## Conflicting Bot Reviews
**Symptoms:**
* Multiple bots review same PR
* Give conflicting feedback
* AI applies one fix, breaks another
* Endless update loop
**Causes:**
* Bots have different standards
* One bot's fix triggers another bot's review
* Circular dependencies in bot rules
* Incompatible linting rules
**Solutions:**
**Disable auto-apply for conflicting bots:**
1. Turn off auto-apply temporarily
2. Manually reconcile bot feedback
3. Apply fixes that satisfy all bots
4. Re-enable auto-apply
**Configure bots to align:**
1. Review bot configuration files
2. Ensure linting rules are compatible
3. Disable overlapping checks
4. Use single bot for similar checks
**Manual reconciliation:**
1. Collect all bot feedback
2. Identify conflicts
3. Determine correct approach
4. Manually apply fixes
5. Test with all bots
**Example:**
```
ESLint: Use single quotes
Prettier: Use double quotes
Solution: Configure both to use same quote style
```
## Bot Review Permissions
**Symptoms:**
* Bot cannot submit reviews
* Bot comments appear but not as reviews
* Auto-apply doesn't recognize bot feedback
* Bot shows access errors
**Causes:**
* Bot lacks review permissions
* Bot not invited to repository
* Bot installation incomplete
* Repository permissions too restrictive
**Solutions:**
**Grant bot review permissions:**
1. Repository settings → Collaborators
2. Add bot account if missing
3. Grant "Write" permission minimum
4. Ensure bot can access repository
**For GitHub App bots:**
1. Check app installation
2. Verify repository is included
3. Review app permissions
4. Reinstall app if needed
**Check bot configuration:**
1. Review bot's settings
2. Verify repository is enabled
3. Check bot is active
4. Test bot on different PR
## Webhook Not Receiving Bot Events
**Symptoms:**
* Manual reviews trigger workflows
* Bot reviews don't
* Webhook logs show user reviews but not bot reviews
* Bot reviews invisible to DevBird
**Causes:**
* Webhook event filters
* GitHub webhook configuration
* Bot reviews sent differently
* Event type mismatch
**Solutions:**
**Check webhook event subscriptions:**
1. Repository settings → Webhooks
2. Click DevBird webhook
3. Verify "Pull request reviews" is checked
4. Save webhook configuration
**Test webhook delivery:**
1. Have bot submit review
2. Check webhook Recent Deliveries
3. Look for review event
4. Check event payload
**Verify event format:**
1. Review webhook payload
2. Ensure contains reviewer info
3. Check reviewer type field
4. Verify action is "submitted"
**Re-register webhook:**
1. Remove DevBird webhook
2. Reinstall DevBird GitHub App
3. Webhook will be recreated
4. Test with bot review
## Rate Limiting Issues
**Symptoms:**
* First bot review works
* Subsequent reviews don't trigger workflows
* Error messages about rate limits
* Workflows rejected
**Causes:**
* GitHub API rate limiting
* DevBird usage limits
* Too many workflow triggers
* Excessive bot activity
**Solutions:**
**GitHub API limits:**
* Wait for rate limit reset (usually 1 hour)
* Reduce bot review frequency
* Stagger bot reviews
* Contact GitHub for higher limits
**DevBird usage limits:**
* Check usage
* Upgrade plan if needed
* Optimize bot usage
* Disable less important bots
**Reduce bot activity:**
```
Current: 10 bots × 5 reviews/day = 50 workflows
Optimized: 3 bots × 2 reviews/day = 6 workflows
```
## Best Practices
For best practices on configuring bot reviews, monitoring costs, and regular auditing, see the [Auto-apply Bot Reviews configuration tips](/devbird/settings#configuration-tips) in the settings documentation.
## Next Steps
* [AI Reviewer Configuration](/devbird/reviewing-prs/ai-reviewer)
* [PR Review Process](/devbird/reviewing-prs)
* [Unit Task Troubleshooting](/devbird/troubleshooting/unit-task)
# Debugging Composite Tasks
Source: https://docs.delino.io/devbird/troubleshooting/composite-task
Common issues with composite tasks and task graphs
## Multiple concurrent PRs
DevBird may create multiple pull requests simultaneously for different tasks. This is expected behavior.
Each PR:
* Represents a separate task or feature
* Can be reviewed independently
* Should be merged individually after approval
Simply review and merge each PR based on its own merits, in any order that makes sense for your workflow.
The content below this warning is still under review. The content may be
inaccurate or outdated.
This guide helps you troubleshoot common issues with composite tasks and task graph execution in DevBird.
## Planning Phase Issues
### Planning Stuck or Takes Too Long
**Symptoms:**
* Composite task stuck in "Planning" status
* Planning workflow running for 30+ minutes
* No task graph generated
**Possible Causes:**
1. Complex project requiring extensive planning
2. Vague or unclear prompt
3. Workflow timeout
4. AI agent error
**Solutions:**
**Check planning workflow status:**
1. Go to GitHub Actions
2. Find the planning workflow run
3. Check logs for errors or stuck steps
**Simplify the prompt:**
* Break very large projects into smaller composite tasks
* Be more specific about requirements
* Provide clear scope boundaries
**Retry planning:**
1. Delete the composite task
2. Create new task with refined prompt
3. Monitor planning progress
### No Plan Generated
**Symptoms:**
* Planning completes but no task graph appears
* Status changes from "Planning" to "Failed"
* Error: "Failed to generate plan"
**Solutions:**
**Check planning workflow logs:**
```
Look for:
- "Generating task graph..."
- Plan file creation
- Upload errors
```
**Verify prompt is actionable:**
* Does it describe a concrete project?
* Are requirements clear?
* Is scope reasonable for AI planning?
**Example good prompts:**
```
Build a REST API for user management with
authentication, CRUD operations, and testing
```
**Example problematic prompts:**
```
Make the app better
Build something cool
```
### Invalid Task Graph
**Symptoms:**
* Plan uploaded but status shows "Failed"
* Error: "Invalid task graph structure"
* Circular dependencies detected
**Causes:**
* AI generated invalid DAG structure
* Circular dependencies in plan
* Missing required fields
**Solutions:**
**This is rare - usually indicates:**
* Very complex/unclear requirements
* Edge case in planning algorithm
**Retry with clearer prompt:**
1. Delete failed composite task
2. Simplify project description
3. Break into smaller composite tasks
4. Create new task
## Task Graph Execution Issues
### No Tasks Marked as Ready
**Symptoms:**
* Clicked "Start Execution"
* Status is "In Progress"
* But no tasks show as "Ready"
* Nothing happens
**Causes:**
* All nodes have dependencies (no starting point)
* Graph structure issue
* Status calculation error
**Solutions:**
**Use Sync feature:**
1. Composite task details page
2. Click "Sync Composite Task"
3. System recalculates node statuses
4. Initial nodes should become ready
**Check task graph visualization:**
* Are there nodes without dependencies?
* These should be ready first
* If all nodes have dependencies, graph is invalid
### Tasks Not Becoming Ready
**Symptoms:**
* Some tasks completed
* But dependent tasks not marked as ready
* Tasks stuck in "Pending" or "Blocked"
**Solutions:**
**Sync composite task:**
1. Go to composite task details
2. Click "Sync Composite Task"
3. System checks dependencies
4. Updates node readiness
**What Sync does:**
* Checks all task PRs in GitHub
* Updates merge statuses
* Recalculates dependencies
* Marks ready nodes
**Check dependency completion:**
* All dependencies must be "Completed"
* If any dependency "Failed", node is "Blocked"
* Review failed dependencies
### Cannot Approve Task
**Symptoms:**
* Task shows as "Ready"
* Approve button doesn't work
* Error when trying to approve
**Solutions:**
**Check task status is "Ready":**
* Only ready tasks can be approved
* Pending/blocked tasks cannot be approved
**Verify you own the composite task:**
* Only the user who created it can approve nodes
* Check you're logged in correctly
**Refresh the page:**
* Status may have changed
* Reload to get latest state
**Sync composite task:**
* Updates all task statuses
* Resolves state inconsistencies
## Auto-Approval Issues
### Auto-Approval Not Working
**Symptoms:**
* Auto-approval enabled
* Tasks become ready
* But not automatically approved/executed
**Solutions:**
**Verify auto-approval is enabled:**
1. Go to composite task details
2. Check "Auto-Approval" toggle is ON
3. Re-enable if needed
**Sync to trigger auto-approval:**
1. Click "Sync Composite Task"
2. System detects ready tasks
3. Auto-approves if enabled
4. Spawns unit tasks
**Check for errors:**
* Review composite task logs
* Look for auto-approval failures
* Verify repository connection
### Want to Disable Auto-Approval
**How to disable mid-execution:**
1. Go to composite task details
2. Toggle "Auto-Approval" to OFF
3. Future ready tasks won't auto-execute
4. Currently running tasks continue
**Note:**
* Already approved tasks continue running
* Only affects tasks that haven't been approved yet
## Task Node Management
### Cannot Edit Task Prompt
**Symptoms:**
* Want to modify task prompt
* Edit button disabled or missing
* Changes don't save
**Possible Causes:**
* Task is in wrong status for editing
* Don't have permission
* Task already executing
**Solutions:**
**Check task status:**
* Can edit: `pending`, `ready`, `blocked`
* Cannot edit: `approved`, `in_progress`, `completed`, `failed`
**For approved tasks:**
* Cannot edit (already executing)
* Cancel spawned unit task if needed
* Retry the node after failure
**For completed/failed tasks:**
* Cannot edit completed work
* Can retry failed tasks
* Retry creates new unit task
### Retry Not Working
**Symptoms:**
* Click "Retry" on failed task
* Nothing happens
* Task remains failed
**Solutions:**
**Check if task is actually failed:**
* Status must be "Failed" or "Approved"
* Can only retry these statuses
**Verify associated unit task:**
* Failed nodes have spawned tasks
* Check unit task status
* May need to delete unit task first
**Sync before retry:**
1. Sync composite task
2. Verifies current state
3. Then retry the node
### Node Stuck in "Approved" Status
**Symptoms:**
* Approved a task
* Status is "Approved"
* But no unit task spawned
* Stays approved indefinitely
**Causes:**
* Unit task creation failed
* System error during spawn
* Connection issue
**Solutions:**
**Retry the node:**
1. Click retry on the approved node
2. Creates new unit task
3. Monitors execution
**Check error logs:**
* Look for task spawn errors
* Verify repository connection
* Check workflow execution permissions
**Sync composite task:**
* May resolve status issues
* Updates task relationships
## Prompt and Context Issues
### Tasks Don't Build on Previous Work
**Symptoms:**
* Later tasks don't reference earlier PRs
* Work is duplicated
* Missing context from dependencies
**Cause:**
* System should automatically include PR references
* May be a timing issue
**Solutions:**
**Ensure dependencies are completed:**
* Wait for dependency PRs to merge
* System includes PR numbers in prompts
* Later tasks reference completed work
**Manual context in prompt edit:**
When approving a task, edit prompt to add:
```
Reference the work completed in PR #123 and PR #456.
Build upon the authentication system from those PRs.
```
**Check dependency PRs are merged:**
* Dependencies should complete before children
* Merged PRs provide context
* Open PRs may not provide enough context
### AI Misunderstands Task Context
**Symptoms:**
* Generated code doesn't align with plan
* Task seems unrelated to project
* Wrong approach taken
**Solutions:**
**Edit prompt before approval:**
1. When task becomes ready
2. Click "Edit Prompt"
3. Add specific context:
```
Continue the work from the database setup task.
Use the User model defined in PR #123.
Follow patterns in @src/models/
```
**Provide file references:**
```
Update @src/services/auth.ts to use the new
JWT tokens from the authentication task.
```
**Request changes via review:**
* After PR is created
* Leave specific guidance
* DevBird will update
## Dependency and Blocking Issues
### Task Blocked by Failed Dependency
**Symptoms:**
* Task shows "Blocked" status
* Dependency task failed
* Cannot proceed
**Solutions:**
**Fix the failed dependency:**
1. Navigate to failed dependency task
2. Review what went wrong
3. Retry the failed task
4. Once it completes, blocked task becomes ready
**Or modify the graph:**
* Delete the blocked task (if not needed)
* Create new unit task as workaround
* Manually complete the work
### Circular Dependency Detected
**Symptoms:**
* Some tasks never become ready
* Mutual dependencies
* Graph seems stuck
**This shouldn't happen:**
* Planning should prevent this
* DAG validation should catch it
**If it does occur:**
1. Report to support with task details
2. Delete composite task
3. Create new task with clearer prompt
4. System will generate valid DAG
## Sync Feature Issues
### Sync Operation Fails
**Symptoms:**
* Click "Sync Composite Task"
* Error message appears
* No updates occur
**Solutions:**
**Check repository connection:**
1. Verify repository is connected
2. Check GitHub App is installed
3. Reconnect if needed
**Try again:**
* Temporary GitHub API issues
* Wait a few minutes
* Retry sync operation
**Check permissions:**
* Must have repository access
* GitHub App needs permissions
* Verify in repository settings
### Sync Shows Wrong Results
**Symptoms:**
* Sync completes
* But task statuses still wrong
* PRs not reflecting correctly
**What to check:**
**PR merge status in GitHub:**
1. Go to GitHub repository
2. Check actual PR status
3. Compare with DevBird display
**Wait for GitHub API:**
* GitHub webhooks may be delayed
* Wait 1-2 minutes
* Retry sync
**Force refresh:**
1. Sync composite task
2. Refresh browser page
3. Check updated statuses
## Performance Issues
### Composite Task Very Slow
**Symptoms:**
* Taking days to complete
* Many tasks waiting
* Progress is slow
**Causes:**
1. Sequential dependencies
2. Waiting for approvals
3. Long-running unit tasks
**Solutions:**
**Enable auto-approval:**
* Eliminates approval delays
* Tasks execute immediately when ready
* Faster overall completion
**Review task graph structure:**
* Too many sequential dependencies?
* Could some tasks be parallel?
* May need better planning
**For future tasks:**
* Provide better context in prompt
* AI will optimize parallelization
* Reduce sequential dependencies
### Too Many Nodes
**Symptoms:**
* Composite task created 50+ nodes
* Overwhelming to manage
* Many small tasks
**Cause:**
* AI over-decomposed the project
* Prompt was too broad
**Solutions:**
**For current task:**
* Enable auto-approval to reduce management
* Let it run automatically
* Monitor progress
**For future tasks:**
* Be more specific about scope
* Request specific number of major steps
* Example: "Break this into 5-8 major tasks"
## Deleting and Canceling
### Cannot Delete Composite Task
**Symptoms:**
* Delete button disabled
* Error when trying to delete
* Task remains
**Solutions:**
**Check for running tasks:**
* Running unit tasks prevent deletion
* Wait for completion
* Or cancel unit tasks first
**Force delete process:**
1. Delete composite task
2. System cancels incomplete unit tasks
3. Blocks all pending nodes
4. Removes composite task
**Verify permissions:**
* Only creator can delete
* Check correct user is logged in
### Partial Deletion Issues
**Symptoms:**
* Composite task deleted
* But some unit tasks remain
* PRs still open
**This is expected:**
* Unit tasks are preserved for history
* PRs remain open (you can close manually)
* Task graph is removed
**To clean up:**
1. Close remaining PRs on GitHub
2. Review unit task history if needed
3. Unit tasks show as "Cancelled"
## Status Display Issues
### Status Shows Incorrect Progress
**Symptoms:**
* Progress shows "3/10 completed"
* But more tasks actually done
* Counts don't match
**Solutions:**
**Sync composite task:**
* Recalculates progress
* Updates node counts
* Fixes display
**What affects count:**
* Only "Completed" nodes count
* Failed nodes don't count as complete
* In-progress nodes don't count yet
### Task Graph Visualization Not Loading
**Symptoms:**
* Graph diagram doesn't appear
* Shows loading spinner forever
* Blank visualization area
**Solutions:**
**Refresh the page:**
* Browser cache issue
* Hard refresh (Ctrl+Shift+R)
**Check browser console:**
* Open dev tools (F12)
* Look for JavaScript errors
* Report if errors found
**Try different browser:**
* Temporary browser issue
* Test in Chrome/Firefox/Safari
## Prevention and Best Practices
### Writing Better Prompts
**Include project structure:**
```
Build a blogging platform with:
1. Backend API (Node.js + Express)
2. Database (PostgreSQL)
3. Frontend (React)
4. Authentication (JWT)
5. Deployment (Docker)
```
**Specify technical stack:**
```
Use TypeScript, follow REST API best practices,
include unit tests, and set up CI/CD.
```
**Define clear boundaries:**
```
Only include core CRUD operations.
Do not include admin panel or analytics.
Focus on MVP functionality.
```
### Monitoring Progress
**Use auto-approval wisely:**
* Enable for trusted, well-defined tasks
* Disable for complex/critical work
* Monitor execution regularly
**Review task graph regularly:**
* Check for blocked nodes
* Identify failed dependencies
* Keep tasks moving forward
**Sync periodically:**
* Ensures accurate status
* Catches missed updates
* Prevents stuck states
### Managing Complexity
**Start smaller:**
* First composite task: 5-8 nodes
* Build confidence
* Scale up gradually
**Break mega-projects:**
* Don't try to build entire app in one task
* Create multiple composite tasks
* Each for a major feature/milestone
**Monitor costs:**
* Composite tasks can be expensive
* Each node = separate workflow execution
* Plan accordingly
## Getting Help
### Information to Provide
When reporting composite task issues:
1. **Composite Task Info:**
* Composite task ID
* Original prompt
* Number of nodes in graph
* Current status
2. **Problematic Nodes:**
* Node IDs having issues
* Node statuses
* Dependencies
3. **Spawned Tasks:**
* Unit task IDs
* Their statuses
* PR numbers
4. **Actions Taken:**
* Sync attempts
* Retry attempts
* What you've tried
### Support Channels
* **Documentation**: [docs.delino.io](https://docs.delino.io)
* **Email**: [support@delino.io](mailto:support@delino.io)
* **For Planning Issues**: Include your original prompt
* **For Graph Issues**: Include screenshot of task graph
## Next Steps
* [Unit Task Troubleshooting](/devbird/troubleshooting/unit-task)
* [Understanding Composite Tasks](/devbird/tasks/composite)
* [Task Graph Best Practices](/devbird/tasks/composite#task-graph-best-practices)
# PR Review Troubleshooting
Source: https://docs.delino.io/devbird/troubleshooting/pr-reviews
Common issues and solutions for DevBird pull request reviews
## PR stuck in draft
**Symptoms:**
* PR remains in draft status
* All checks passing but not ready for review
* Cannot merge PR
**Solution:**
1. Check CI status - ensure all checks are passing
2. Verify auto-undraft is enabled in [Settings](/devbird/settings)
3. Manually undraft the PR if needed
4. Check if there are pending review comments
## DevBird not responding to reviews
**Symptoms:**
* Reviewer submitted feedback
* No workflow triggered
* PR not updated
* PR not converting to draft
* No response to feedback
**Possible causes:**
* Reviewer hasn't connected the repository in DevBird
* Bot reviews with auto-apply disabled
* GitHub webhook not configured or delivery failing
* Review was a simple approval (doesn't trigger workflow)
* Review type doesn't trigger workflow
* Repository not connected
**Solution:**
**Ensure reviewer has repository access:**
1. Reviewer must connect the repository in DevBird
2. Verify repository appears in reviewer's dashboard
3. Check that DevBird GitHub App is installed
**Enable auto-apply for bot reviews:**
See [Auto-apply Bot Reviews](/devbird/settings#auto-apply-bot-reviews) in the settings documentation for details on enabling this feature.
**Verify webhook configuration:**
1. Repository settings → Webhooks
2. Check DevBird webhook exists
3. Verify webhook is active
4. Check recent delivery status
**Check GitHub webhook logs:**
1. Go to repository settings on GitHub
2. Navigate to Webhooks
3. Find DevBird webhook
4. Check recent deliveries for errors
5. Redeliver failed webhooks if needed
**Check review type:**
* Simple approvals don't trigger workflows
* Comments must be submitted with "Request changes" or "Comment"
* Verify review was actually submitted (not just comment)
**Manual trigger:**
1. Go to task details
2. Click "Update PR"
3. Enter update instructions
4. Workflow will trigger manually
## CI fixes not working
**Symptoms:**
* CI checks failing
* DevBird not attempting fixes
* PR remains with failed checks
**Possible causes:**
* Already attempted fix for this commit (rate limited)
* Workflow execution failed
* GitHub Actions quota exceeded
* DevBird webhook not receiving check events
**Solution:**
**Push new commit to allow new fix attempt:**
```bash theme={null}
git commit --allow-empty -m "Trigger CI fix attempt"
git push
```
**Check workflow execution logs:**
1. Go to task details page
2. Find workflow executions
3. Look for "ci\_fix" type workflows
4. Review error messages
**Verify GitHub Actions quota:**
1. Check repository Actions tab
2. Verify workflows can run
3. Check organization billing if quota exceeded
**Manual fix alternative:**
1. Review CI failure logs
2. Make fixes locally
3. Push updates to PR branch
## Too many automated updates
**Symptoms:**
* PR receives excessive updates
* Multiple workflow runs
* High costs
* Reviewers confused by constant changes
**Causes:**
* Task prompt too vague
* Review feedback unclear
* Multiple bots triggering updates
* CI checks failing repeatedly
**Solution:**
**Break tasks into smaller units:**
* Create focused, single-purpose tasks
* Avoid complex multi-step tasks
* Use composite tasks for large projects
**Be more specific in initial prompt:**
```
Good: Fix null pointer exception in UserService.authenticateUser()
when email field is missing
Bad: Fix the bug
```
**Manually review and update PRs:**
1. Disable auto-apply temporarily
2. Review accumulated feedback
3. Make consolidated updates
4. Re-enable auto-apply
**Limit bot reviews:**
1. Configure bots to review less frequently
2. Adjust bot sensitivity
3. Use auto-apply selectively
## Next steps
* [PR Review Process](/devbird/reviewing-prs)
* [Unit Task Troubleshooting](/devbird/troubleshooting/unit-task)
* [Composite Task Troubleshooting](/devbird/troubleshooting/composite-task)
# Debugging Unit Tasks
Source: https://docs.delino.io/devbird/troubleshooting/unit-task
Common issues with unit tasks and how to resolve them
This document is still under review. The content may be inaccurate or
outdated.
This guide helps you troubleshoot common issues with unit tasks in DevBird.
## Task Creation Issues
### Task Not Starting
**Symptoms:**
* Task stuck in "Pending" status
* No workflow execution visible in GitHub Actions
* Task created but nothing happens
**Possible Causes:**
1. Workflow file missing or incorrect
2. GitHub Actions disabled
3. Repository not properly connected
4. Workflow dispatch failed
**Solutions:**
**Check workflow file exists:**
```bash theme={null}
# Verify file exists
ls .github/workflows/devbird.yml
# Check file is on default branch
git branch --show-current
```
**Verify GitHub Actions is enabled:**
1. Go to repository Settings
2. Navigate to Actions → General
3. Ensure "Allow all actions and reusable workflows" is selected
**Reconnect repository:**
1. DevBird → Repositories
2. Find your repository
3. Click "Disconnect" then "Reconnect"
**Manually retry:**
1. Go to task details page
2. Click "Retry Task" button
3. Check workflow execution logs
### Invalid Configuration Error
**Symptoms:**
* Task fails immediately
* Error: "Invalid agent configuration"
* Workflow execution shows configuration error
**Possible Causes:**
1. AI agent API key not set
2. Invalid agent type specified
3. Model type not supported
**Solutions:**
**Verify API key:**
1. Repository Settings → Secrets → Actions
2. Check required secret exists (e.g., `ANTHROPIC_API_KEY`)
3. Regenerate key if needed
**Check agent configuration:**
* Agent type must be one of the [supported AI agents](/devbird/getting-started/ai-agent)
* Model type must match agent's supported models
**Use default settings:**
* Leave agent/model fields empty to use team defaults
* Verify team defaults in Settings page
## Workflow Execution Issues
### Workflow Fails to Trigger
**Symptoms:**
* Task status changes to "In Progress" but no GitHub Actions run
* No workflow run visible in Actions tab
* Task eventually times out
**Solutions:**
**Check workflow permissions:**
```yaml theme={null}
permissions:
id-token: write
contents: write
pull-requests: write
actions: read
```
**Verify workflow dispatch event:**
```yaml theme={null}
on:
workflow_dispatch: # Must be present
inputs:
devbird_task_token:
required: true
```
**Check GitHub API status:**
* Visit [githubstatus.com](https://www.githubstatus.com)
* Look for API or Actions outages
### Workflow Hangs or Timeouts
**Symptoms:**
* Workflow runs for extended period
* Eventually times out (2+ hours)
* No progress updates
**Solutions:**
**Add timeout to workflow:**
```yaml theme={null}
jobs:
devbird:
runs-on: ubuntu-latest
timeout-minutes: 60 # 1 hour max
```
**Check runner availability:**
* If using self-hosted runners, verify they're online
* Switch to GitHub-hosted runners temporarily
**Simplify the task:**
* Break large task into smaller pieces
* Reduce scope of changes requested
* Be more specific in prompt
### Authentication Errors
**Symptoms:**
* Error: "Authentication failed"
* Error: "Invalid task token"
* Workflow fails at authentication step
**Solutions:**
**Verify OIDC is configured:**
```yaml theme={null}
permissions:
id-token: write # Required for OIDC
```
**Check task token is passed:**
```yaml theme={null}
- uses: delino-io/devbird-action@v1
with:
task_token: ${{ inputs.devbird_task_token }} # Must be present
```
**Repository must be connected:**
1. Verify repository appears in DevBird
2. Status should be "Connected"
3. Reconnect if needed
## Pull Request Creation Issues
### No PRs Created
**Symptoms:**
* Task completes successfully
* Status changes to "Completed"
* But no pull requests appear
**Possible Causes:**
1. AI determined no changes were needed
2. Changes were made but no branches registered
3. PR creation failed silently
**Solutions:**
**Check workflow logs:**
1. Go to GitHub Actions
2. Find the workflow run
3. Look for "Creating pull request" steps
4. Check for any errors
**Verify task prompt was clear:**
* Was the request specific enough?
* Did you specify what to create/change?
* Try rephrasing and creating new task
**Check branch was created:**
```bash theme={null}
# List all branches
git branch -a
# Look for devbird-* branches
git branch -a | grep devbird
```
**Task may have legitimately completed without changes:**
* AI analyzed request
* Determined changes weren't needed
* This is normal behavior for some prompts
### PR Created on Wrong Branch
**Symptoms:**
* PR targets wrong base branch
* Changes based on wrong branch
**Solutions:**
**Specify base branch when creating task:**
1. In task creation form
2. Expand "Advanced Settings"
3. Set "Base Branch" to desired branch (e.g., "develop")
**Update workflow default:**
```yaml theme={null}
base_branch:
required: false
default: "develop" # Change from 'main'
```
**For existing PR:**
* You can change the base branch on GitHub
* Go to PR → Click "Edit" near title
* Change base branch in dropdown
### Multiple Unwanted PRs
**Symptoms:**
* Task creates too many PRs
* PRs are fragmented
* Changes should be in one PR
**Cause:**
* AI decided to split changes across multiple PRs
* This is sometimes intentional for large changes
**Solutions:**
**For future tasks:**
* Add to prompt: "Create all changes in a single PR"
* Be more specific about scope
**For existing PRs:**
* Manually merge the branches
* Close extra PRs
* Keep the main one
## Code Quality Issues
### Generated Code Doesn't Compile
**Symptoms:**
* CI checks fail
* Code has syntax errors
* Build fails
**Solutions:**
**Let DevBird auto-fix:**
* Wait for automatic CI fix workflow
* DevBird detects failures and attempts fixes
* Usually completes in 5-10 minutes
**Provide feedback via review:**
1. Leave review comment on specific lines
2. Request changes
3. DevBird will update the code
**Manual update request:**
1. Go to task details
2. Click "Update PR"
3. Provide specific fix instructions
### Code Doesn't Match Requirements
**Symptoms:**
* Code works but doesn't do what you wanted
* Missing features
* Wrong approach
**Solutions:**
**Review and request changes:**
1. Leave detailed review comments
2. Explain what's wrong and what you expected
3. Request changes on GitHub PR
4. DevBird will address feedback
**Update the PR:**
1. Task details → Update PR
2. Provide additional context
3. Clarify requirements
**Create new task:**
* If changes are too different
* Delete current task
* Create new task with clearer prompt
### Code Style Doesn't Match Project
**Symptoms:**
* Code formatting is different
* Naming conventions don't match
* Structure is inconsistent
**Solutions:**
**Request style fixes:**
* Leave review comment
* Reference your style guide
* Example: "Please follow naming conventions in @CONTRIBUTING.md"
**Set up linters:**
* Add ESLint, Prettier, or other formatters to CI
* DevBird will see failures and auto-fix
**Improve future prompts:**
```
Follow the code style in @src/services/example.ts
Use the same patterns as existing services
```
## Status and Sync Issues
### Task Stuck "In Progress"
**Symptoms:**
* Task has been "In Progress" for hours/days
* Workflow completed but status didn't update
* PRs are created but task status unchanged
**Solutions:**
**Sync task status:**
1. Go to task details page
2. Click "Sync Task" (in debug/actions menu)
3. DevBird checks PR status and updates task
**Check workflow execution:**
* Look at workflow execution history
* See if workflow actually completed
* Check for errors in logs
**Manual status check:**
* If all PRs are merged → Task should be "Completed"
* If PRs are closed without merge → Task should be "Failed"
* Sync operation will fix this
### Task Status Incorrect
**Symptoms:**
* Task shows "Completed" but PRs still open
* Task shows "Failed" but PRs are merged
* Status doesn't reflect reality
**Solution:**
**Use Sync Task feature:**
1. Task details page
2. Sync Task button
3. Checks GitHub for actual PR status
4. Updates task status accordingly
**What Sync does:**
* Fetches latest PR data from GitHub
* Checks merge status
* Updates CI check status
* Recalculates task status
### Cannot Delete Task
**Symptoms:**
* Delete button doesn't work
* Error when trying to delete
* Task remains after delete attempt
**Solutions:**
**Check permissions:**
* Only task creator can delete
* Verify you're logged in as correct user
**Task may be running:**
* Wait for workflow to complete
* Cancel workflow first, then delete
**Force delete:**
1. Close all PRs manually on GitHub
2. Wait a few seconds
3. Retry delete in DevBird
## Performance Issues
### Task Takes Too Long
**Symptoms:**
* Task runs for 30+ minutes
* Much slower than expected
* Workflow seems stuck
**Possible Causes:**
1. Large codebase
2. Complex task
3. Slow AI agent response
4. Runner resource constraints
**Solutions:**
**Break into smaller tasks:**
* Split large request into focused tasks
* Each task completes faster
* Better for tracking progress
**Use faster agent/model:**
* Switch to GPT-3.5 or Claude Haiku
* Faster response times
* Trade quality for speed
**Optimize workflow:**
* Remove unnecessary setup steps
* Cache dependencies
* Use faster runner (self-hosted)
### Rate Limit Errors
**Symptoms:**
* Error: "Rate limit exceeded"
* Task fails with 429 error
* API quota exceeded
**Solutions:**
**For GitHub API limits:**
* Wait an hour for reset
* Reduce concurrent tasks
* Use GitHub App authentication (automatic)
**For AI provider limits:**
* Check provider dashboard for quota
* Upgrade API plan
* Wait for rate limit reset
* Switch to different agent temporarily
## Debugging Workflow Logs
### Finding Workflow Logs
1. Go to repository on GitHub
2. Click "Actions" tab
3. Find "DevBird" workflow
4. Click on the specific run
5. Click on job name to see logs
### Important Log Sections
**Authentication:**
```
Authenticating with DevBird...
✓ Task token validated
✓ OIDC token exchanged
```
**Agent Execution:**
```
Running Claude Code...
Analyzing codebase...
Generating changes...
```
**PR Creation:**
```
Creating pull request...
✓ Branch created: devbird-task-123
✓ PR #456 created
```
### Common Error Messages
**"No ANTHROPIC\_API\_KEY found"**
* API key not set in repository secrets
* Add secret and retry task
**"Branch already exists"**
* Previous task created same branch
* Delete branch on GitHub
* Retry task
**"Permission denied"**
* Workflow permissions missing
* Add required permissions to workflow file
**"Task token invalid"**
* Task may have been deleted
* Try creating new task
* Check repository is connected
## Getting Help
### Information to Provide
When requesting support, include:
1. **Task Details:**
* Task ID
* Repository name
* Task prompt
* Agent and model used
2. **Workflow Information:**
* GitHub Actions run URL
* Workflow logs (relevant sections)
* Error messages
3. **PR Information:**
* PR numbers created
* PR status
* Review comments
4. **Steps Taken:**
* What you've tried
* Results of each attempt
### Where to Get Help
* **Documentation**: [docs.delino.io](https://docs.delino.io)
* **Email Support**: [support@delino.io](mailto:support@delino.io)
* **GitHub Issues**: For workflow file problems
* **AI Provider Support**: For API/model issues
## Prevention Tips
### Write Clear Prompts
```
✓ Good: "Fix null pointer exception in UserService.java line 45
when email is empty. Add validation and return 400 error."
✗ Vague: "Fix the bug in user service"
```
### Test Incrementally
* Start with simple tasks
* Verify each task works
* Build confidence before complex tasks
### Monitor Costs
* Track workflow execution count
* Monitor AI provider usage
* Set up usage alerts
### Regular Maintenance
* Keep workflow file updated
* Rotate API keys periodically
* Review and clean up old tasks
## Next Steps
* [Composite Task Troubleshooting](/devbird/troubleshooting/composite-task)
* [PR Review Process](/devbird/reviewing-prs)
* [AI Agent Configuration](/devbird/getting-started/ai-agent)
# Introduction
Source: https://docs.delino.io/index
Welcome to Delino Apps documentation!