Builder Interface

The Builder Interface is where you create AI applications using natural language. Simply describe what you want to build, and Empromptu's AI agents will create a complete application with embedded mod

What you'll learn ⏱️ 6 minutes

• How to access and navigate the Builder interface

• How to effectively describe your AI application

• Best practices for prompting the Builder

• Using example prompts and recent chats

• The iterative building and refinement process

• When to deploy vs continue building

Accessing the Builder

Click "Builder" in the left sidebar of your Empromptu dashboard. You'll see the main building interface with the heading "Build an AI App Agentically."

Builder Interface Elements:

Main Input Field:

• Large text area asking "What are you building?"

• This is where you describe your AI application in natural language

Example Prompts:

• Pre-written suggestions to get you started

• Click any example to populate the input field

• Examples include common AI application types

Recent Chats:

• Shows "No previous conversations" for new users

• Displays chat history once you've used the Builder

• Click any previous conversation to continue where you left off

How the Builder Works

Unlike Other Builders:

Traditional builders use AI to create static websites and user interfaces.

Empromptu's Builder creates complete AI applications with:

• Embedded AI models for intelligent processing

• RAG capabilities for knowledge retrieval

• Production infrastructure ready for real users

• Built-in LLMOps for optimization and monitoring

Building Process:

1. Describe your application in natural language

2. Answer clarifying questions to ensure accuracy and avoid wasted credits

3. AI agents analyze your requirements and responses

4. Complete application generated with all components

5. Continue iterating or access LLMOps for optimization

Effective Prompting Strategies

Be Specific About Functionality

❌ Vague: "Build a chatbot" ✅ Specific: "Build a customer support chatbot that handles billing questions, password resets, and refund requests"

❌ Vague: "Create a data processor" ✅ Specific: "Build a document analyzer that extracts contact information, company details, and key metrics from business proposals"

Include Context and Requirements

Good prompting includes:

• Purpose: What problem does this solve?

• Users: Who will use this application?

• Functionality: What should it do specifically?

• Output format: How should results be presented?

Example: Comprehensive Prompt

Build a Review Summarizer that analyzes customer reviews and extracts key insights, emotional reactions, and overall sentiment. The application should:- Process product reviews from multiple sources- Identify positive and negative sentiment patterns- Extract specific features customers mention- Generate concise summaries highlighting main themes- Present results in an easy-to-read format for product managersUsers will be product managers who need to quickly understand customer feedback trends.

Common Application Types

Customer Support Applications

Example prompt:

"Build a customer support assistant that can handle common inquiries about billing, account issues, and product information. It should escalate complex issues to human agents and maintain a helpful, professional tone."

What gets built:

• Intelligent inquiry routing

• Knowledge base integration

• Escalation logic

• Response generation with brand voice

Data Processing Applications

Example prompt:

"Create a document processor that extracts structured data from invoices, including vendor information, line items, totals, and due dates. Output should be formatted as structured data for accounting systems."

What gets built:

• Document parsing capabilities

• Data extraction logic

• Structure formatting

• Integration-ready output

Content Generation Applications

Example prompt:

"Build a content generator for social media posts that creates engaging captions based on product descriptions, maintains brand voice, and suggests relevant hashtags for maximum reach."

What gets built:

• Content creation logic

• Brand voice consistency

• Hashtag recommendation system

• Social media optimization

Analysis and Insights Applications

Example prompt:

"Create a competitive analysis tool that analyzes competitor websites, extracts key product features, pricing information, and marketing messages, then generates comparison reports."

What gets built:

• Web scraping capabilities

• Feature extraction logic

• Comparison algorithms

• Report generation system

Using Example Prompts

The Builder interface provides example prompts to help you get started:

Available Examples:

• "Build a chatbot for your enterprise users"

• "Build a AI Finance App"

• "Build an app that writes grants"

• "Build an app that summarizes insights for engineering execs"

• "Build an SEO app that researches keywords every week"

How to Use Examples:

1. Click any example to populate the input field

2. Customize the prompt to match your specific needs

3. Add details about your requirements and context

4. Submit to begin building

Customizing Examples:

Take "Build a chatbot for your enterprise users" and customize it:

Build a chatbot for enterprise users that helps employees with:- IT support requests and troubleshooting- HR policy questions and benefits information  - Facility management (booking rooms, reporting issues)- Internal process guidance and documentationThe chatbot should integrate with our existing Slack workspace and escalate complex issues to appropriate departments.

Iterative Building Process

Initial Build Phase:

1. Submit your prompt describing the application

2. Answer clarifying questions - The Builder asks follow-up questions to ensure it understands your requirements completely before generating the app (this helps avoid wasting credits on incorrect builds)

3. Wait 30-60 seconds for AI agents to build after clarification

4. Review the generated application in the Builder interface

5. Test basic functionality to ensure it meets requirements

Builder Clarification Process

After submitting your initial prompt, the Builder may ask clarifying questions to ensure accurate app generation:

Common clarification questions:

• "Who are the primary users of this application?"

• "What specific data sources should this connect to?"

• "How should the output be formatted or structured?"

• "Are there any specific business rules or constraints?"

• "What level of accuracy or performance is required?"

How to respond effectively:

• Be specific: Provide concrete details rather than general answers

• Include examples: Give sample inputs/outputs when possible

• Mention constraints: Note any limitations or requirements

• Clarify scope: Define what's included and what's not

Benefits of the clarification process:

• Prevents incorrect builds that waste credits

• Ensures complete functionality from the first generation

• Reduces need for major revisions later

• Creates more accurate applications that match your needs

Refinement Phase:

Continue the conversation to improve your application after the initial build:

Add features:

"Add the ability to handle multiple languages and translate responses to the user's preferred language."

Modify behavior:

"Make the responses more concise and include action items when appropriate."

Integrate with systems:

"Connect this to our CRM system to pull customer information during conversations."

Improve accuracy:

"Add better error handling for edge cases and unclear user inputs."

When to Stop Building:

• Core functionality works as expected

• Ready for optimization (move to Projects tab)

• Need to test with real data (use LLMOps tools)

• Want to deploy (use deployment buttons)

Advanced Builder Techniques

Multi-Step Applications:

Describe complex workflows clearly:

"Build a content approval workflow that:1. Receives content submissions from writers2. Checks for brand compliance and quality standards  3. Routes to appropriate reviewers based on content type4. Tracks approval status and provides feedback5. Publishes approved content to designated channels"

Integration Requirements:

Specify external systems and data sources:

"Create a sales intelligence tool that integrates with our Salesforce CRM to analyze prospect data, identifies warm leads based on engagement patterns, and generates personalized outreach recommendations for our sales team."

Industry-Specific Applications:

Include domain expertise requirements:

"Build a medical report analyzer for radiology practices that extracts key findings from diagnostic reports, flags urgent cases requiring immediate attention, and generates summary reports in standardized medical terminology for physician review."

Deployment from Builder

Deployment Options:

In the top right of the Builder interface, you'll find deployment buttons:

Deploy to Netlify: One-click hosting on Netlify's platform Deploy to GitHub: Push your application to a GitHub repository Download Project: Get files for self-hosting anywhere

When to Deploy:

• Application functions correctly in Builder testing

• Ready for real user testing or production use

• Want to share with stakeholders for feedback

• Need to integrate with existing systems

Before Deploying:

Consider using LLMOps tools first:

• Set up evaluations to define success criteria

• Add test inputs to validate performance

• Run optimization to improve accuracy

• Test edge cases to ensure reliability

Moving to LLMOps

When to Access Projects Tab:

• Want to optimize performance beyond basic functionality

• Need to set up monitoring for production use

• Want to improve accuracy with real data

• Ready for systematic testing and evaluation

Builder vs Projects Workflow:

Builder: Create and refine application functionality Projects: Optimize performance and prepare for production

You can move back and forth between Builder and Projects as needed throughout development.

Best Practices

Prompt Writing:

• Start specific: Clear requirements lead to better results

• Include context: Explain the use case and users

• Specify output: Describe expected results format

• Iterate gradually: Make one change at a time

• Answer clarifications thoroughly: Provide detailed responses to Builder questions

Building Strategy:

• Build core functionality first: Get basic features working

• Engage with clarification process: Take time to answer questions completely

• Test early and often: Validate functionality before adding complexity

• Document requirements: Keep notes on what works and what doesn't

• Plan for optimization: Consider LLMOps needs during building

Common Mistakes to Avoid:

• Too vague initial prompts: Leads to generic applications

• Trying to build everything at once: Complex requirements confuse the Builder

• Skipping testing: Deploy without validating functionality

• Ignoring optimization: Deploy without using LLMOps capabilities

Troubleshooting Builder Issues

Builder Not Responding:

Check: Internet connection and try refreshing Solution: Wait a moment and try again

Generated App Doesn't Match Requirements:

Check: Prompt clarity and specificity Solution: Refine prompt with more specific details

App Functionality Issues:

Check: Requirements complexity and technical feasibility Solution: Break down into simpler components and build iteratively

Can't Continue Previous Conversation:

Check: Recent Chats section for conversation history Solution: Look for your previous conversation or start fresh

Next Steps

Now that you understand the Builder Interface:

• Learn Projects and Tasks: Understand how your built applications are organized

• Master Task Actions: Access optimization tools for your applications

• Understand Accuracy Metrics: Learn how performance is measured

• Start with Optimization: Begin improving your application's performance