Skip to main content

​
Overview

Blocks enables you to delegate technical tasks directly from conversations in Slack, Linear, or GitHub. Simply describe what you need done, and Blocks will handle the implementation, testing, and documentation—allowing your team to focus on higher-level work.

​
How It Works

When you delegate a task to Blocks, it will:
  1. Parse the Request: Extract the requirements from your natural language description
  2. Gather Context: Review relevant code, documentation, and related work
  3. Execute the Task: Implement the changes following your codebase patterns
  4. Test Changes: Run tests and validate the implementation
  5. Deliver Results: Create a PR or provide a summary of completed work

​
Using Task Delegation

​
Simple Delegation

Delegate straightforward tasks: 
@blocks add error handling to the login endpoint

@blocks update the README with the new deployment process

@blocks refactor the UserController to use async/await

​
Complex Delegation

Delegate multi-step tasks: 
@blocks implement rate limiting for our API, add tests, and update docs

@blocks migrate the database schema to support multi-tenancy

@blocks add monitoring and alerting for the payment service

​
With Constraints

Specify requirements or constraints: 
@blocks add caching but maintain backward compatibility

@blocks optimize this query without changing the API response structure

@blocks implement this feature following the existing pattern in UserService

​
Where to Delegate

​
From Slack Conversations

Turn discussions into action items: 
@blocks based on this thread, create a Linear ticket with technical details and implement it

​
From Linear Issues

Delegate implementation directly: 
@blocks implement this ticket and address the edge cases we discussed

​
From GitHub PRs

Request changes or improvements: 
@blocks address these review comments and update the PR

​
Task Types You Can Delegate

  • Feature Implementation: Add new functionality or capabilities
  • Bug Fixes: Resolve issues and edge cases
  • Refactoring: Improve code structure and maintainability
  • Testing: Add or improve test coverage
  • Documentation: Update README, API docs, or inline comments
  • Performance: Optimize slow queries or inefficient code
  • Security: Fix vulnerabilities or improve security posture
  • Infrastructure: Update configs, dependencies, or deployment scripts

​
Plan Mode for Large Tasks

For substantial tasks, use Plan Mode to review the approach before implementation: 
@blocks /plan redesign the authentication system to support SSO
This creates an implementation plan you can review and refine before Blocks begins coding. Learn more about Plan Mode.

​
Best Practices

  • Clear Instructions: Provide specific requirements and expected outcomes
  • Include Context: Reference related files, tickets, or conversations
  • Set Constraints: Mention any limitations or requirements upfront
  • Break Down Large Tasks: Delegate smaller, focused tasks for better results
  • Review Work: Always review generated code and test thoroughly
  • Provide Feedback: Help Blocks improve by giving feedback on results

​
Session Continuity

Blocks maintains context within a conversation thread, allowing you to:
  • Ask follow-up questions
  • Request modifications
  • Add additional requirements
  • Clarify edge cases
@blocks implement user profile editing
# After seeing initial response:
Also add profile picture upload support

​
Integration Setup

Task Delegation works seamlessly across all Blocks integrations:
  • Slack - Delegate from team discussions
  • Linear - Delegate from issue management
  • GitHub - Delegate from code reviews

​
Learn More