Atlas E74243keac
Help Center›Development Guide!›Guide To Prompt
Table of contents
  • 🚀 Starting Your Build Journey
  • Strategic Planning Session
  • 🔧 Incremental Development Strategy
  • Managing Development Flow
  • 🐛 Effective Error Reporting
  • Quality Assurance
  • 💾 Strategic Checkpoint Management
  • Session Continuity
  • 🔄 Scaling & Iteration
  • Managing Scope Changes
  • Advanced Features Implementation
  • 🎯 Best Practices Summary
  • Communication Excellence
  • Technical Excellence
  • ⚠️ Common Pitfalls

    • Guide To Prompt

    Last updated June 30, 2025

    🚀 Starting Your Build Journey

    Define clear Business or Personal goals:

    • Begin with your basic business goal, idea, and desired features without technical requirements.
    • Use plain language to describe what you want to build.

    Craft Effective Initial Prompts Based on Emergent Agent capabilities, structure your initial prompt with:

    **Business Goal:** [Clear, simple description]
**Core Features:** [List 3-5 main features]
**Target Users:** [Who will use this]
**Success Criteria:** [How you'll measure success]

    Best Practices for Initial Prompts:

    • Be explicit and specific - Emergent Agents respond better to clear and concise instructions.
    • Provide context and motivation - Explain WHY features are important, not just WHAT you want.
    • Use positive framing - Tell the Emergent Agent what TO do instead of what NOT to do.
    • Add quality modifiers: Instead of "Create a dashboard," use "Create a comprehensive analytics dashboard with interactive features and modern design principles".

    Strategic Planning Session

    • Agent will plan the task and ask question regarding planning and prioritization.
    • Always guide the agent as per your use case.
    • If you wish to brainstorm with the agent, use: "Chat with me and don't build right now" followed by your questions.
    • Discuss potential challenges and solutions upfront.
    • Once aligned, say: "Start building based on what we discussed".

    🔧 Incremental Development Strategy

    Feature Implementation Rules

    • Implement 1-2 features maximum per development cycle.
    • Complete each feature fully before moving to the next.
    • Test each increment thoroughly before proceeding.

    Optimal Prompting for Development

    • Use detailed modifiers: example "Include hover states, transitions, and micro-interactions".
    • Request comprehensive implementations: example "Go beyond the basics to create a fully-featured implementation".
    • Specify quality expectations: example "Apply modern design principles: hierarchy, contrast, balance, and movement".

    Managing Development Flow

    Never Mix Errors and Features

    • Separate concerns: Address bugs in dedicated messages, implement new features in separate messages.
    • Clear context switching: Complete error resolution before requesting new features.

    Avoid Interrupting Emergent Agent Mid-Process

    • Emergent Agents follow instructions precisely - interrupting can create unfinished features.
    • Let the Emergent Agent complete its current task before providing new directions.
    • If you must interrupt, clearly state: "Please finish your current task, then we'll discuss [new topic]".

    🐛 Effective Error Reporting

    Test Frontend Yourself First

    • Always test the application in your browser before reporting issues.
    • Document specific error messages, browser console errors, and steps to reproduce.
    • Include screenshots or screen recordings when helpful.

    Error Communication Protocol

    • Test thoroughly yourself first.
    • Document all errors found.
    • Provide clear reproduction steps.
    • Share exact error messages.
    • Only then engage Agent for debugging.

    When Emergent Agent Can't Resolve Errors

    • Ask the Emergent Agent to test the frontend itself if you're missing errors.
    • The Emergent Agent can identify issues not visible in the UI that might be causing problems.
    • Provide browser developer console logs if available.

    Quality Assurance

    Leverage Emergent Agent Capabilities

    • Request specific testing: "Test all interactive elements and validate responsive design".
    • Ask for comprehensive reviews: "Review the code for potential issues and suggest improvements".

    💾 Strategic Checkpoint Management

    Regular GitHub Commits

    • Push code to GitHub after each major feature completion.

    Context Management

    • When approaching context limits, always push to GitHub first.
    • Before clearing context: Ask the Emergent Agent to create a comprehensive summary including:
    • What has been implemented
    • Current status of all features
    • Remaining items in the implementation plan
    • Known issues or technical debt
    • Next recommended steps

    Rollback Strategy

    • Use rollback tools when approaching context limits or want to go back to a working checkpoint in code.
    • It's better to rollback to a working state than to debug extensively corrupted code.
    • Emergent Agents can occasionally make complex mistakes due to their advanced capabilities.

    Session Continuity

    Starting New Sessions

    • Pull latest code from GitHub.
    • Provide the Emergent Agent with the implementation summary from the previous session.
    • Clearly state: "Continue from where we left off based on this summary". You can also add any specific changes or directions that you want the agent to adhere or first respond to.
    • Reference the specific features that were in progress.

    🔄 Scaling & Iteration

    Managing Scope Changes

    Scope Discipline

    • Avoid major scope changes mid-development - they can break existing functionality.
    • Minor deviations are acceptable, but major pivots require starting fresh.
    • Complete the current version before considering significant changes.

    When to Start Fresh

    • If you want to fundamentally change the application concept.
    • When technical architecture needs complete overhaul.
    • If too many breaking changes accumulate.

    Advanced Features Implementation

    Performance Optimization

    • Request specific performance improvements: "Optimize for loading speed and smooth interactions".
    • Ask for modern best practices: "Implement using current web development best practices".
    • Specify accessibility requirements: "Ensure full accessibility compliance".

    🎯 Best Practices Summary

    Communication Excellence

    • Be explicit and detailed - Emergent Agents reward specificity.
    • Provide context and reasoning - Explain the "why" behind requests.
    • Use positive instructions - Focus on what you want, not what you don't want.
    • Add quality modifiers - Encourage comprehensive, high-quality implementations.

    Technical Excellence

    • Build and Test incrementally - Validate each feature before proceeding.
    • Maintain clean separation - Don't mix bug fixes with new feature requests.
    • Use version control religiously - Commit working code frequently.

    ⚠️ Common Pitfalls

    • Starting to build without clear business requirements.
    • Sharing too much technical requirements, that is not inline with agent’s capabilities.
    • Mixing error reports with new feature requests.
    • Interrupting the agent mid-process.
    • Changing scope dramatically mid-development.
    • Not testing features before reporting bugs.
    • Forgetting to commit working code to GitHub.
    • Not providing implementation summaries when clearing context.

    Remember: Modern AI agents are exceptionally capable but require precise, thoughtful prompting to deliver optimal results. The investment in clear communication and structured development processes will yield significantly better applications.

    For any questions or assistance, feel free to email us at  support@emergent.sh 

    Was this article helpful?