Skip to main content

​
Overview

HAI Build integrates with Specif AI to enable seamless execution of AI-generated user stories and development tasks. This powerful integration allows you to:
  • Load AI-generated tasks directly into HAI Build
  • Review task details before execution
  • Execute tasks with a single click
  • Track task progress and completion

​
Accessing HAI Tasks

Open the HAI Tasks interface in multiple ways:
1

From the Sidebar

Click the HAI Tasks icon (checklist icon) in the HAI Build sidebar toolbar.
2

From Command Palette

  1. Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
  2. Type HAI Tasks
  3. Select HAI Build: HAI Tasks
The HAI Tasks feature provides a centralized interface for managing all AI-generated development tasks.

​
Understanding the Task Interface

The HAI Tasks page displays:

​
User Stories View

Tasks are organized by user stories, providing high-level context:
  • Story Title: Overview of the feature or requirement
  • Story Description: Detailed context and objectives
  • Associated Tasks: List of individual tasks for the story
  • Eye Icon: Click to view detailed story information

​
Task Details

Each task includes:
  • Task Title: Clear description of the specific work
  • Prerequisites: Dependencies or requirements before starting
  • Acceptance Criteria: Conditions that define task completion
  • Implementation Notes: Additional context or guidance

​
Executing Tasks

Follow this workflow to execute HAI Tasks:
1

Review the User Story

Click the Eye icon next to a user story to view:
  • Detailed story description
  • Overall objectives
  • List of associated tasks
  • Dependencies and context
Understanding the full story context helps HAI make better decisions during task execution.
2

Select a Task

From the story detail view or task list:
  1. Click on a specific task to expand details
  2. Review the task description, prerequisites, and acceptance criteria
  3. Ensure all prerequisites are met before proceeding
3

Execute the Task

Click the Execute or Run button to start task execution.HAI Build will:
  • Load the task context into the AI agent
  • Analyze your codebase for relevant files
  • Create an execution plan
  • Present the plan for your review
4

Review and Approve

HAI presents a detailed plan showing:
  • Files to be modified or created
  • Proposed changes
  • Reasoning for each change
Review the plan carefully before approving.
5

Monitor Execution

Watch as HAI executes the task:
  • File operations are shown in real-time
  • Progress updates appear in the chat
  • Proposed diffs are displayed for approval
Always review diffs before accepting changes. You maintain full control throughout execution.
6

Verify Completion

After execution:
  1. Review all changes made
  2. Test the implementation
  3. Verify acceptance criteria are met
  4. Run tests if applicable

​
Task Execution Best Practices

Before executing a task:
  • Ensure all prerequisite tasks are completed
  • Verify required dependencies are installed
  • Check that your development environment is properly configured
This prevents errors and ensures smooth execution.
Take time to understand:
  • What the task is trying to accomplish
  • Why it’s part of the larger user story
  • How it fits into your application architecture
Provide additional context to HAI if the task description lacks details.
For related tasks within a story:
  • Execute them in the order specified
  • Complete and verify one task before starting the next
  • This maintains logical flow and prevents conflicts
If HAI’s approach doesn’t align with your architecture:
  • Pause and provide clarification
  • Reference specific files or patterns to follow
  • Suggest alternative implementations
HAI adapts based on your feedback.
After task execution:
  • Run relevant test suites
  • Manually test new functionality
  • Ensure acceptance criteria are fully met
  • Check for unintended side effects

​
Managing Multiple Tasks

When working with multiple tasks:

​
Parallel vs Sequential Execution

Sequential Execution (Recommended): 
1. Execute Task A
2. Review and test changes
3. Commit changes
4. Execute Task B
5. Review and test changes
6. Commit changes
Why Sequential?
  • Easier to isolate issues
  • Cleaner commit history
  • Better code review process
  • Reduced risk of conflicts

​
Task Priority

Prioritize tasks based on:
  • Dependencies: Complete prerequisite tasks first
  • Complexity: Start with simpler tasks to build momentum
  • Risk: Address high-risk changes when you have full attention
  • Impact: Consider which tasks unlock the most value

​
Handling Task Execution Issues

If a task won’t start:
  1. Check Prerequisites: Verify all dependencies are met
  2. Review Context: Ensure HAI has necessary file access
  3. Simplify Request: Break complex tasks into smaller steps
  4. Provide More Context: Add relevant files or documentation to the chat

​
Integration with Specif AI

HAI Tasks work seamlessly with the Specif AI workflow:
1

Generate User Stories in Specif AI

Use Specif AI to analyze requirements and generate:
  • User stories
  • Task breakdowns
  • Acceptance criteria
2

Export to HAI Build

Tasks generated in Specif AI are automatically available in HAI Build’s HAI Tasks interface.
3

Execute in HAI Build

Select and execute tasks directly from the HAI Tasks page.
4

Track Progress

Monitor completion status across both platforms.
This integration creates a seamless flow from requirements gathering to implementation.

​
Advanced Task Execution

​
Custom Task Context

Enhance task execution with additional context: 
Before executing a task, you can provide:
- Architecture diagrams or documentation
- Coding standards or style guides
- Related code examples
- API documentation
Add these by:
  1. Opening the task
  2. Clicking in the chat input
  3. Pasting or dragging files before execution

​
Expert Modes

For domain-specific tasks, activate relevant experts:
  • .NET Expert: For .NET/C# tasks
  • Node.js Expert: For Node.js/JavaScript tasks
  • Terraform Expert: For infrastructure as code
  • Go Expert: For Go language tasks
  • Custom Experts: Your own domain-specific guidelines
Experts provide specialized knowledge and best practices during task execution.

​
Next Steps

Code Generation

Learn advanced code generation techniques

Git Integration

Commit task changes with AI-generated messages

Custom Experts

Create experts for your specific tech stack

MCP Integration

Extend capabilities with Model Context Protocol
Questions? Check out our GitHub Discussions or contact us at [email protected]

Build docs developers (and LLMs) love

Get started for freeTalk to us