Experts

Experts provide domain-specific knowledge and best practices to guide AI code generation. HAI Build comes with four built-in experts and supports custom experts for your unique tech stack.

Experts in Action

What are Experts?

Experts are specialized AI assistants that:

Provide guidelines for specific technologies or domains
Include best practices from industry standards
Reference documentation for accurate code generation
Maintain consistency across your codebase
Reduce errors by following proven patterns

Experts integrate directly into the AI’s system prompt, influencing every decision it makes during code generation.

Built-In Experts

HAI Build includes four production-ready experts:

.NET Expert

Expertise:

ASP.NET Core web applications
Entity Framework Core
Dependency injection patterns
C# best practices
.NET ecosystem tools

Use for:

Web APIs and microservices
Enterprise applications
Azure cloud integrations

Terraform Expert

Expertise:

Infrastructure as Code
AWS, Azure, GCP providers
Module design patterns
State management
Security best practices

Use for:

Cloud infrastructure provisioning
Multi-cloud deployments
Infrastructure automation

Node.js Expert

Expertise:

Express.js and Fastify
TypeScript for Node
npm ecosystem
Async patterns and promises
Testing with Jest/Mocha

Use for:

Backend services
REST and GraphQL APIs
Serverless functions

Go Expert

Expertise:

Idiomatic Go patterns
Concurrency with goroutines
Standard library usage
Error handling
Testing and benchmarking

Use for:

High-performance services
CLI tools
Distributed systems

Built-in experts are read-only and maintained by the HAI Build team. For customization, create a custom expert.

Custom Experts

Create your own experts tailored to your team’s needs:

Open Experts Panel

Navigate to the Experts section in HAI Build sidebar.

Create New Expert

Click “Create Custom Expert” and provide:

Name: Descriptive identifier (e.g., “React with Redux”)
Guidelines: Markdown-formatted best practices
Document Links: Up to 3 reference URLs (optional)

Configure Guidelines

Write your expert’s guidelines in Markdown:

# React Component Best Practices

## Functional Components
- Always use functional components with hooks
- Prefer `const` for component declarations
- Use TypeScript for all components

## State Management
- Use Redux Toolkit for global state
- Keep component state local when possible
- Avoid prop drilling with Context API

## Performance
- Memoize expensive computations with `useMemo`
- Use `React.memo` for pure components
- Lazy load routes with `React.lazy`

Add Documentation (Optional)

Provide URLs to reference documentation:

Official docs
Internal wikis
Best practice guides

HAI Build will download and process these for the AI.

Save and Activate

Your custom expert is now available for selection.

Expert Storage Structure

Custom experts are stored in your workspace:

workspace/
├── .hai-experts/
│   ├── react-redux/
│   │   ├── metadata.json
│   │   ├── prompt.md
│   │   └── docs/
│   │       ├── react-docs.md
│   │       ├── redux-toolkit.md
│   │       └── status.json
│   └── python-fastapi/
│       ├── metadata.json
│       └── prompt.md

metadata.json
prompt.md
docs/
status.json

Stores expert configuration:

{
  "name": "React with Redux",
  "createdAt": "2026-03-03T10:30:00Z",
  "documentLinks": [
    "https://react.dev/learn",
    "https://redux-toolkit.js.org/"
  ]
}

Contains the expert’s guidelines:

# React Component Best Practices

## Component Structure
- Use functional components
- Apply TypeScript strictly
...

Required: Every expert must have a prompt.md file.

Tracks documentation processing:

{
  "lastUpdate": "2026-03-03T10:35:00Z",
  "documents": {
    "react-docs.md": "processed",
    "redux-toolkit.md": "processing"
  }
}

See README description: Lines 116-146

Using Experts

Selecting an Expert

Open Expert Selector

Click the expert icon in the chat interface or settings.

Choose Expert

Select from built-in or custom experts.

Confirm Selection

The expert’s guidelines are now active for all AI interactions.

Expert-Guided Code Generation

Once an expert is active:

System Prompt Enhancement: Expert guidelines are injected into the AI’s system prompt
Context-Aware Responses: AI follows expert’s best practices
Consistent Patterns: Code matches your defined standards
Documentation References: AI can cite expert documentation

Example:

Without Expert

User: “Create a React component for a user profile”AI generates:

import React from 'react'

class UserProfile extends React.Component {
  render() {
    return <div>{this.props.name}</div>
  }
}

export default UserProfile

With React Expert

User: “Create a React component for a user profile”AI generates (following expert guidelines):

import React, { FC } from 'react'

interface UserProfileProps {
  name: string
  email: string
}

export const UserProfile: FC<UserProfileProps> = ({ name, email }) => {
  return (
    <div className="user-profile">
      <h2>{name}</h2>
      <p>{email}</p>
    </div>
  )
}

Expert Guidelines Best Practices

Be Specific and Actionable

❌ “Write good code”✅ “Use TypeScript strict mode. Always define return types for functions. Prefer const over let.”

Include Examples

## Error Handling

Always wrap async operations in try-catch:

\`\`\`typescript
try {
  const data = await fetchUser(id)
  return data
} catch (error) {
  logger.error('Failed to fetch user', error)
  throw new UserFetchError(error)
}
\`\`\`

Organize by Topic

Structure guidelines hierarchically:

# Python FastAPI Expert

## Project Structure
- Use `app/` directory for application code
- Separate routes, models, and services

## Dependency Injection
- Use FastAPI's `Depends` for services
- Define dependencies in `app/dependencies.py`

## Testing
- Use pytest for all tests
- Mock external services with `unittest.mock`

Reference Authoritative Sources

Link to official documentation:

Follow the [Official TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/)
for advanced type patterns.

Document Processing

When you add document links to an expert:

URL Validation

HAI Build validates the URLs and checks accessibility.

Content Fetching

Downloads the documentation content.

Markdown Conversion

Converts HTML/PDF to clean Markdown format.

Storage

Saves processed docs in the expert’s docs/ folder.

Status Tracking

Updates status.json with processing status.

Document processing happens asynchronously. Large documentation sites may take several minutes to process.

Supported Document Types

Web pages: HTML documentation
GitHub README: Markdown from repositories
API docs: OpenAPI/Swagger specifications
PDFs: Technical guides (experimental)

Documents are re-processed when links change or every 30 days to ensure freshness.

Expert Use Cases

Team Standards

Codify your team’s conventions:

Naming conventions
File organization
Comment styles
Git commit formats

Framework Patterns

Enforce framework-specific patterns:

Next.js app router conventions
Django REST framework structure
Spring Boot annotations
Rails ActiveRecord patterns

Security Guidelines

Embed security best practices:

Input validation rules
Authentication patterns
Secret management
SQL injection prevention

Testing Standards

Define testing expectations:

Unit test structure
Integration test patterns
Mocking strategies
Coverage requirements

API Design

Standardize API development:

RESTful conventions
GraphQL schema design
Error response formats
Versioning strategies

Database Patterns

Guide database interactions:

ORM usage
Migration patterns
Query optimization
Transaction handling

Advanced Expert Features

Multi-Expert Scenarios

Scenario: Full-stack application

Backend Expert

Use Node.js expert for API development

Frontend Expert

Switch to React expert for UI components

Infrastructure Expert

Apply Terraform expert for deployment

Switch experts mid-task by selecting a different expert. The AI adapts immediately.

Combining Experts with Other Features

+ HAI Tasks
+ Focus Chain
+ Custom Instructions

Apply experts to task execution:

Load tasks from Specif AI
Select appropriate expert (e.g., .NET for backend tasks)
Execute tasks with expert guidance
Consistent code across all task outputs

Layer experts with .clinerules:

Expert provides domain knowledge (e.g., React patterns)
.clinerules adds project-specific rules (e.g., component library usage)
Combined context for optimal results

Editing Experts

Locate Expert Files

Navigate to .hai-experts/<expert-name>/

Edit prompt.md

Modify guidelines in your preferred editor:

code .hai-experts/react-redux/prompt.md

Update metadata.json (Optional)

Change expert name or add/remove document links.

Reload Expert

HAI Build automatically detects changes. If not, restart the task.

Important: Changes to built-in experts are not supported. Clone a built-in expert to create a customized version.

Share experts across teams:

Commit to Git

Add .hai-experts/ to version control:

git add .hai-experts/
git commit -m "Add React Redux expert"

Team Members Pull

Others clone the repository and get the expert automatically.

Centralized Updates

Update expert guidelines in one place, everyone benefits.

Create a dedicated repository for organization-wide experts and reference it as a git submodule.

Troubleshooting

Expert not appearing

Check .hai-experts/ folder exists
Verify prompt.md file is present
Ensure metadata.json is valid JSON
Restart HAI Build extension

Document processing failed

Verify URLs are accessible
Check network connectivity
Review status.json for error details
Try removing and re-adding the link

AI not following expert guidelines

Verify expert is selected/active
Check guidelines are clear and specific
Ensure guidelines don’t conflict with task requirements
Try rephrasing guidelines with examples

Expert changes not reflected

Save all files in expert directory
Restart current task
Clear HAI Build cache
Reload VS Code window

Best Practices Summary

Start Simple

Create basic experts with core guidelines before adding complexity.

Iterate Based on Output

Review AI-generated code and refine expert guidelines accordingly.

Use Examples Liberally

Code examples are more effective than abstract rules.

Keep Guidelines Focused

One expert per domain/framework. Don’t mix unrelated concerns.

Version Control Experts

Treat expert files as code—commit, review, and version them.

Document Rationale

Explain why certain patterns are preferred in comments.

Next Steps

AI-Powered Coding

See how experts integrate with AI workflows

Task Management

Use experts with HAI Tasks for consistent results

Custom Instructions

Layer experts with .clinerules for maximum control

Focus Chain

Apply experts across multi-step task execution

Get Started

Core Features

Configuration

Usage Guides

Advanced

What are Experts?

Built-In Experts

.NET Expert

Terraform Expert

Node.js Expert

Go Expert

Custom Experts

Expert Storage Structure

Using Experts

Selecting an Expert

Expert-Guided Code Generation

Expert Guidelines Best Practices

Document Processing

Supported Document Types

Expert Use Cases

Team Standards

Framework Patterns

Security Guidelines

Testing Standards

API Design

Database Patterns

Advanced Expert Features

Multi-Expert Scenarios

Combining Experts with Other Features

Editing Experts

Troubleshooting

Best Practices Summary

Next Steps

AI-Powered Coding

Task Management

Custom Instructions

Focus Chain

​What are Experts?

​Built-In Experts

.NET Expert

Terraform Expert

Node.js Expert

Go Expert

​Custom Experts

​Expert Storage Structure

​Using Experts

​Selecting an Expert

​Expert-Guided Code Generation

​Expert Guidelines Best Practices

​Document Processing

​Supported Document Types

​Expert Use Cases

Team Standards

Framework Patterns

Security Guidelines

Testing Standards

API Design

Database Patterns

​Advanced Expert Features

​Multi-Expert Scenarios

​Combining Experts with Other Features

​Editing Experts

​Sharing Experts

​Troubleshooting

​Best Practices Summary

​Next Steps

AI-Powered Coding

Task Management

Custom Instructions

Focus Chain

What are Experts?

Built-In Experts

Custom Experts

Expert Storage Structure

Using Experts

Selecting an Expert

Expert-Guided Code Generation

Expert Guidelines Best Practices

Document Processing

Supported Document Types

Expert Use Cases

Advanced Expert Features

Multi-Expert Scenarios

Combining Experts with Other Features

Editing Experts

Sharing Experts

Troubleshooting

Best Practices Summary

Next Steps