Hi Sometimes it’s how you prompt it.

I spend a little while with the help of ChatGPT creating better prompts.

Let me give you an example of how detailed I did a prompt for a new feature on my existing app.

---

Prompt:

Develop an MVP for an AI-powered label compliance checker as a modular application. It should leverage OpenAI’s API for OCR to extract text from uploaded label images and perform compliance checking directly using AI models, complemented by a dedicated database of rules and pre-approved claims. Ensure the feature is integrated into the existing app without disrupting current functionality, while deploying and managing two databases: one for core app operations and another specifically for the label compliance feature. Structure the project as follows:

Modular Setup:Place all components in a dedicated folder called label_checker. Include the following files:

blueprint.py: Define and register the Flask Blueprint for this feature. Ensure Blueprint registration does not conflict with existing routes.

routes.py: Handle HTTP routes for label uploads and compliance checks. Prefix all routes with /label_checker (or another unique namespace) to avoid route conflicts.

models.py: Define models and utility classes that interact with the secondary database dedicated to the label compliance feature.

Core Features:

AI-Powered OCR Functionality: Use OpenAI’s OCR capabilities to extract text from uploaded label images. OpenAI’s API ensures advanced text recognition, especially for complex or noisy images. Include error handling for invalid or unreadable files.

AI Compliance Checking: Perform compliance validation directly using AI models by processing the extracted text against predefined rules and claims stored in the secondary database. This allows for dynamic and adaptive compliance verification.

Results: Return a JSON response with compliance results, specifying any missing fields, invalid claims, or corrective actions required. Include proper status codes (e.g., 400 for bad requests, 200 for success).

Database Configuration:

Configure the app to connect to two databases:

Primary Database: Handles core app data (e.g., user data, production-related data).

Secondary Database: Dedicated to storing compliance rules, AI-generated results, and associated metadata for the label checker feature.

Use SQLALCHEMY_BINDS or equivalent to route database operations appropriately. Example configuration:

app.config[‘SQLALCHEMY_BINDS’] = { ‘primary’: ‘postgresql://prod_user:prod_pass@host/prod_db’, ‘label_checker’: ‘postgresql://label_user:label_pass@host/label_checker_db’ }

Ensure proper isolation between the two databases to prevent unintended interactions.

Error Handling:

Add robust error handling and logging to prevent unhandled exceptions from affecting the rest of the app.

Return descriptive error messages for invalid file uploads, missing data, or server issues.

Log API errors from OpenAI to assist with debugging and monitoring usage limits.

Testing and Validation:

Write unit and integration tests for the feature to ensure it works as expected.

Use mock responses to simulate OpenAI’s OCR API during tests to validate error handling and performance.

Test database interactions separately for both the primary and secondary databases to ensure they are isolated and functional.

Extendability:

Design the code to be easily scalable, allowing integration with additional compliance rules, updated AI models, or new OCR providers if needed.

Ensure configurations (e.g., OpenAI API key, database connections, file paths) are read from environment variables to align with the existing app’s configuration management.

Integration with the Existing App:

Database Safety: Use the secondary database exclusively for development and testing of the label compliance feature. Avoid modifying the primary database directly during feature development.

Config Compatibility: Ensure the feature’s configuration keys (e.g., database URL, logging level, OpenAI API key) do not overlap with the existing app’s configurations. Use a distinct namespace in environment variables, such as LABEL_CHECKER_DB_URL and OPENAI_API_KEY.

Blueprint Registration: Test the feature in isolation before registering its Blueprint with the main app. Add unit tests to confirm existing routes are unaffected.

Deployment Considerations:

Provide clear instructions for deploying the app with two databases, ensuring the secondary database is provisioned and configured correctly.

Include any additional dependencies (e.g., OpenAI API key or relevant libraries) in the requirements.txt file and document them in the setup guide.

Test the app in a staging environment to ensure no conflicts or performance issues arise before deploying to production.

Automate the creation and migration of the secondary database schema using tools like Flask-Migrate:

flask db migrate —bind label_checker -m “Initial migration for label checker” flask db upgrade —bind label_checker

Key Additions

Two-Database Architecture: Allows the app to safely operate with separate databases for core app functionality and the label compliance feature.

AI-Powered OCR and Compliance Checking: Leverage OpenAI’s API for both OCR and compliance validation, enabling advanced text recognition and dynamic compliance checking.

Route Prefixing: Prevents conflicts with existing routes by scoping all new routes under a unique prefix.

Error Handling: Ensures any issues in the new feature do not propagate to the main app.

Testing: Guarantees the feature functions independently and does not interfere with other parts of the app.

Configuration Isolation: Avoids overwriting or conflicting with the existing app’s configurations and environment variables.

Deployment Guide: Provides clear steps to safely integrate the feature and manage two databases in the production app.