The Development category in AIUNIFY PROS SUITE provides twelve subscriber-facing tools for working with SQL, source code, technical documentation, testing, OCR, deployment configuration, environment templates, scheduling expressions, and Git exclusions:
The Sidebar routes these tools respectively to /sql, /bug-fix, /code-reviewer, /api-docs, /readme-generator, /regex-generator, /unit-test, /ocr, /cron-expression, /docker-compose, /env-template, and /gitignore-generator.
The Development category contains two specialized workspaces:
The other ten tools use the shared Standard AI Generator Workspace documented in Chapter 12.
The specialized tools provide controls not found in Standard ToolPage.
Provides:
Provides:
These ten use Standard ToolPage:
.env Template BuilderA critical distinction throughout Chapter 36 is:
The Development tools generate, explain, review, or transform technical content. They do not automatically execute that content on your computer, server, database, repository, or production infrastructure.
Generating a SQL Query does not run it.
Generating Unit Tests does not run the test suite.
Generating Docker Compose does not deploy Containers.
Generating a .env Template does not configure a server.
Generating .gitignore content does not modify a Git repository.
Navigate to:
Sidebar → Development → SQL Builder
Route:
/sql
The SQL route requires an authenticated AIUNIFY PROS SUITE session.
An unauthenticated visitor is redirected toward /login.
The actual workspace title is:
AI SQL Builder
Current description:
“Convert plain English queries into optimized SQL statements for database operations.”
The left-side Card is:
Query Builder
with:
“Describe what you want to query in plain English.”
SQL Builder provides:
Database Type (Optional).
The current selector includes:
A database does not have to be selected.
If none is selected, the Prompt asks for generic:
SQL syntax.
SQL dialects differ.
Selecting the intended database can help the AI account for syntax differences involving:
Selecting:
PostgreSQL
does not connect PROS SUITE to an actual PostgreSQL server.
It is generation context only.
The primary Textarea is:
Describe Your Query.
Current example:
“Example: Find all customers who placed orders in the last 30 days...”
Subscribers can describe the desired result instead of manually writing SQL.
For example:
“Find active subscribers who joined in the past 90 days and have made more than three purchases.”
Generation requires non-whitespace text.
Current Error:
Error
with:
“Please enter a query description.”
Primary action:
Generate SQL.
While the AI request is active:
Generating...
The current Prompt requests:
SQL Builder uses a database-oriented system instruction that tells AI to:
The AI operation uses:
sql
as its Tool ID.
SQL Builder uses the shared AI streaming architecture.
The subscriber's currently selected AI Model can therefore be used for generation.
The shared streaming pathway can also use subscriber-configured provider API Keys as described in Chapter 11.
SQL Builder currently contains five example requests:
The first three examples appear under:
Quick Examples:
Selecting one fills the Query Description field.
All five examples also appear in:
Example Queries
with:
“Click on any example to try it out.”
The right side is titled:
Generated SQL
with:
“Your optimized SQL query will appear here.”
The generated response appears under:
Preview.
A second Tab is:
Edit.
After AI generation completes, you can directly edit the generated response in a monospace Textarea.
While generation is still active, the Edit field cannot be modified.
The AI is asked to return:
The client then stores the entire AI response in sqlQuery.
It does not isolate only the executable SQL statement.
Because the complete response is stored, Generated SQL may contain:
rather than only a raw Query.
After generation, the page also displays:
Explanation:
followed by:
“Query generated successfully. Review the SQL statement above.”
The separate Explanation area does not contain the AI-generated detailed explanation.
The AI explanation remains part of the main generated response.
The Edit Tab provides:
Copy SQL.
Success:
Copied
with:
“SQL query copied to clipboard.”
Because sqlQuery contains the full AI response, Copy SQL currently copies the complete stored response—not necessarily a clean SQL-only statement.
Review and isolate executable SQL before pasting it into a database client.
SQL Builder does not currently expose a dedicated Download action.
.sql File ExportThere is no source-verified automatic .sql export.
SQL Builder does not ask for:
The Tool cannot inspect your live database schema.
There is no visual list of:
There is no:
Run Query
against an actual database.
The Tool does not return rows from a real database.
It does not run:
against a live database.
Although AI attempts to produce appropriate SQL, the generated statement is not source-verified by a real database parser before it is shown.
The Tool does not automatically protect a production database from destructive statements such as:
because it never executes them.
Before running generated SQL:
The current feature catalogue assigns:
SQL Query Builder — 15 Tokens.
SQL Builder itself does not display its Token Cost beside Generate SQL.
Treat 15 Tokens as the current catalogue/reference amount.
Navigate to:
Sidebar → Development → Bug Fix
Route:
/bug-fix
Actual title:
Bug Fix Assistant.
“Identify and fix bugs in your code with AI-powered debugging.”
“Paste your buggy code and describe the issue you're experiencing...”
“Fix this JavaScript function that returns undefined.”
“Debug this Python script with a TypeError.”
“Find the bug in this React component that won't render.”
Current catalogue and route reference:
20 Tokens.
The configured Development Prompt describes the Tool as a debugging expert that should:
For better results, include the exact:
when available.
Specify relevant information such as:
Bug Fix uses the Standard Prompt Textarea.
There is no source-code file-upload control.
The Tool does not connect directly to:
Generated fixes do not change your application's source files.
The Tool does not run the submitted code.
There is no:
The Tool does not automatically confirm that its proposed fix solves the bug.
Include:
Language + framework + code + exact error + expected behavior + actual behavior + relevant environment details.
Navigate to:
Sidebar → Development → Code Review
Route:
/code-reviewer
The page itself is titled:
Code Reviewer.
“Get AI-powered code reviews with suggestions for improvement.”
“Paste your code for review. Include context about what it should do...”
“Review this API endpoint for security issues.”
“Check this React component for performance optimizations.”
“Review this Python function for best practices.”
Current catalogue/default:
25 Tokens.
The configured Development Prompt asks AI to review code for:
The submitted text is analyzed by the selected AI Model.
It is not compiled or executed.
Only the information supplied in your Prompt is available unless separately included.
There is no native Pull Request connection in this Tool.
The Tool returns one generated response.
It does not annotate source files line-by-line inside a code editor.
Code Reviewer is not a replacement for:
No source-verified ESLint, Pylint, PHPStan, RuboCop, or comparable linter is executed.
Specify what you want prioritized:
Navigate to:
Sidebar → Development → API Docs
Route:
/api-docs
The actual workspace title is:
API Documentation Generator.
“Generate comprehensive API documentation from your code or endpoints.”
“Describe your API endpoints, methods, and parameters...”
“Document this REST API for user authentication.”
“Create OpenAPI spec for an e-commerce API.”
“Generate documentation for these GraphQL queries.”
Current catalogue/default:
30 Tokens.
The Development Prompt defines the API Docs Tool as a technical writer expected to create documentation covering:
The Sidebar label API Docs does not mean subscriber access to an AIUNIFY public API management console.
This page does not create:
There is no repository scan or server inspection.
Provide the API information yourself.
You can ask for:
but the ToolPage does not independently validate the resulting specification.
No interactive API explorer is implemented.
The Tool does not send requests against the documented API.
No source-verified Postman Collection export exists.
Even if the generated content represents YAML or JSON, the ToolPage Download action saves:
api-docs-output.txt
rather than a native .yaml or .json file.
Provide:
Navigate to:
Sidebar → Development → README
Route:
/readme-generator
README Generator.
“Create professional README files for your GitHub projects.”
“Describe your project, its features, and how to use it...”
“README for a React component library.”
“Documentation for a CLI tool.”
“Project README for an open-source API.”
Current catalogue/default:
20 Tokens.
The configured Development instruction calls for:
You can explicitly request:
The Tool does not automatically inspect an actual repository.
There is no dedicated file-upload or repository import.
Paste relevant existing content into the Prompt if needed.
The Tool does not save README content to a repository.
README.mdThe current Standard ToolPage Download pattern produces:
readme-generator-output.txt
rather than automatically creating:
README.md
After reviewing the output, copy it into your project's README.md or rename/save it using the appropriate development workflow.
Navigate to:
Sidebar → Development → Regex
Route:
/regex-generator
Regex Generator.
“Generate and explain regular expressions for pattern matching.”
“Describe the pattern you want to match...”
“Regex to validate email addresses.”
“Pattern to match phone numbers in US format.”
“Expression to extract URLs from text.”
Current catalogue/default:
10 Tokens.
The configured Development Prompt tells AI to:
Regex syntax differs among environments.
Include the intended engine or language, such as:
The current Tool does not run the expression against a real regex engine.
There is no dedicated:
Despite the AI's ability to explain and suggest test cases, the Standard page does not programmatically validate the Regex.
Include:
Navigate to:
Sidebar → Development → Unit Tests
Route:
/unit-test
Unit Test Generator.
“Generate comprehensive unit tests for your code.”
“Paste your code and specify the testing framework...”
“Generate Jest tests for this React component.”
“Create pytest tests for this Python function.”
“Write unit tests for this TypeScript class.”
Current catalogue/default:
20 Tokens.
The configured Development Prompt requests:
Examples:
Tell the AI about frameworks, libraries, and external services the code depends on.
Generated Tests are not executed.
The Tool does not measure:
There is no Pass/Fail execution report.
Generated Test files are not added to your codebase automatically.
Standard Download produces:
unit-test-output.txt
not a framework-specific .test.ts, .spec.js, .py, or other source file.
Generate → Review → Copy Into Test File → Run Locally/CI → Fix Failures → Refine Tests
Navigate to:
Sidebar → Development → OCR Tool
Route:
/ocr
The OCR route requires authenticated PROS SUITE access and redirects unauthenticated users toward /login.
The specialized workspace is:
AI OCR Tool.
Current page description:
“Extract text from images and documents with high accuracy using advanced OCR technology.”
Although the description says images and documents, the current Input control accepts:
image/*
only.
Therefore, the current subscriber workflow should be documented as:
Image OCR
rather than general PDF/DOCX document OCR.
The left Card is:
Upload Image
with:
“Select an image file to extract text from it.”
Select:
Click to upload image.
The visible page states:
Supports JPG, PNG, GIF, WebP.
The file picker technically accepts any browser file represented by an image/* MIME type.
The visible interface specifically advertises JPG, PNG, GIF, and WebP.
If the selected file is not recognized as an Image:
Error
with:
“Please select a valid image file.”
The current OCR page validates file Type but does not contain a source-verified maximum file-size check.
This does not guarantee that upstream AI/service limits cannot reject an oversized Image.
After choosing an Image, the page displays:
Preview:.
The selected Image is shown in a fixed-height preview region using object-cover.
There is no separate:
Extract Text
button.
Choosing a valid Image immediately begins the AI OCR operation.
While extraction is active, the upload region changes to:
Processing Image...
The client converts the selected Image to Base64 before submitting it to the AI streaming workflow.
The AI is asked to:
The AI request uses:
ocr.
The broader configured OCR instruction similarly directs the AI to extract text clearly, format it readably, and note unclear areas.
OCR uses the shared streaming system, so the currently selected compatible AI Model can be used.
The shared Model/provider-key pathway can apply as documented in Chapters 10 and 11.
The right-side Card is:
Extracted Text
with:
“Text extracted from your image will appear here.”
Extracted content appears progressively as AI returns it.
OCR output uses AIUNIFY's Markdown Renderer.
Before an Image is uploaded:
“Upload an image to extract text.”
When extracted text exists, select:
Copy Text.
Current notification:
Copied
with:
“Text copied to clipboard.”
The OCR output does not contain a subscriber-editable Textarea.
There is no Download action.
The current file picker does not accept PDFs.
DOCX is not accepted.
There is no page-navigation or multi-page OCR interface.
The source reads only the first selected file.
There is no multi-file upload workflow.
The visible area resembles an upload zone, but the current implementation opens the file picker when clicked.
No source-verified drag/drop event handlers are present in the inspected component.
The subscriber cannot choose:
through a dedicated OCR Language field.
The interface promotes high accuracy, but extracted text should still be verified—especially for:
Current feature catalogue:
OCR Tool — 15 Tokens.
The OCR page itself does not show the 15-Token amount beside upload.
Navigate to:
Sidebar → Development → Cron Builder
Route:
/cron-expression
The actual page title is:
Cron Expression Builder.
“Generate and explain cron schedule expressions from natural language — with validation and reverse translation.”
“Describe the schedule you need in plain English...”
“Run every weekday at 9:00 AM — generate the cron expression and explain each field.”
“Execute every 15 minutes between 8 AM and 6 PM on weekdays only.”
“Explain this cron expression: 0 */4 * * 1-5 and suggest alternatives.”
The route supplies:
10 Tokens.
The current shared feature catalogue assigns:
20 Tokens.
Because Standard ToolPage prioritizes:
Live AI Limit → Feature Catalogue → Route Fallback
the current default base reference is:
20 Tokens
unless a live AI-limit setting overrides it.
Despite the Tool description mentioning validation, the page uses Standard ToolPage.
There is no separate Cron parser or scheduler engine visible in this route.
The Tool does not create a scheduled server Task.
It does not modify:
crontab
on your machine or VPS.
There is no dedicated Cron Time Zone field.
Include the intended Time Zone in the Prompt when it matters.
Specify the target environment where relevant, such as:
because Cron formats are not universally identical.
Download saves:
cron-expression-output.txt
rather than installing or executing the schedule.
Navigate to:
Sidebar → Development → Docker Compose
Route:
/docker-compose
Docker Compose Generator.
“Generate production-ready docker-compose.yml files from stack descriptions with networking, volumes, and environment config.”
“Describe your application stack — services, databases, caching, and any other dependencies...”
“Next.js app with PostgreSQL, Redis, and Nginx reverse proxy — generate docker-compose.yml.”
“Python Django app with MySQL, Celery, RabbitMQ, and Elasticsearch.”
“Full MERN stack with MongoDB, Express, React, Node.js, and a development hot-reload setup.”
The route supplies:
15 Tokens.
The current feature catalogue assigns:
20 Tokens.
Current default base:
20 Tokens
unless overridden by live AI-limit configuration.
The Tool description uses the phrase:
production-ready.
However, the generated Compose configuration is AI-produced text and is not source-verified through a Docker deployment or configuration validator before presentation.
Verify:
before production use.
The Tool does not connect to Docker Desktop or Docker Engine.
It does not run:
docker compose up
It does not pull Docker Images.
No live Container console exists.
The ToolPage does not run:
docker compose config
against the generated output.
No VPS or Cloud environment is modified.
.txtThe generated output downloads as:
docker-compose-output.txt
not automatically:
docker-compose.yml.
After reviewing the generated text, copy the YAML content into the appropriately named Compose file in your development environment.
.env Template Builder.env TemplateNavigate to:
Sidebar → Development → .env Template
Route:
/env-template
.env Template Builder.
“Generate well-documented .env template files with variable names, sensible defaults, and inline documentation for any tech stack.”
“Describe your tech stack and the services/APIs your app connects to...”
“Next.js app with Supabase auth, Stripe payments, SendGrid email, and Vercel deployment.”
“Django project with PostgreSQL, AWS S3, Redis, and Sentry error tracking.”
“Express.js API with MongoDB, JWT auth, Cloudinary uploads, and Twilio SMS.”
The route supplies:
10 Tokens.
The shared feature catalogue assigns:
20 Tokens.
Absent a live override:
20 Tokens.
This Tool generates a Template.
It is not a secret-management system.
For template creation, use placeholders such as:
DATABASE_URL=your_database_url
rather than exposing actual:
The Tool does not provide source-verified:
The Tool does not inspect an existing application automatically.
.env InstallationGenerated content is not placed into your project folder.
It does not configure Vercel Environment Variables.
It does not update AWS Secrets Manager or Parameter Store.
It does not create Docker Secrets.
Current Standard ToolPage saves:
env-template-output.txt
rather than .env or .env.example.
Describe Stack → Generate → Remove Any Sensitive Values → Verify Variable Names → Copy Into .env.example → Fill Real Secrets Through the Appropriate Secure Environment
Navigate to:
Sidebar → Development → Git Ignore
Route:
/gitignore-generator
The actual page title is:
Git Ignore Generator.
“Create comprehensive .gitignore files tailored to your tech stack, frameworks, IDEs, and operating systems.”
“List your programming languages, frameworks, IDEs, and operating systems...”
“Python + Django + Docker + VS Code + macOS — generate a comprehensive .gitignore.”
“Node.js + TypeScript + Next.js + JetBrains IDE + Windows.”
“Java + Spring Boot + Gradle + IntelliJ IDEA + Linux with CI/CD artifacts.”
The route supplies:
5 Tokens.
The feature catalogue assigns:
20 Tokens.
Absent a live AI-limit override, Standard ToolPage's current base reference is:
20 Tokens.
The Tool does not inspect the files actually present in your project.
It does not write .gitignore into a repository.
It does not commit the generated file.
Adding a path to .gitignore does not itself stop Git from tracking a file that is already committed.
That repository operation must be handled separately.
.gitignoreThe generated output downloads as:
gitignore-generator-output.txt.
Before committing code, verify that sensitive material such as:
.envis appropriately excluded when required.
The ten Standard Development tools share the ToolPage architecture documented in Chapter 12.
Standard ToolPage displays:
The left Card is:
Input
with:
“Describe what you want to generate.”
The Tool-specific placeholder appears inside the Textarea.
Primary action:
Generate.
While active:
Generating...
Within Standard ToolPage:
Ctrl + Enter
starts generation.
Each Standard Development Tool provides three Tool-specific examples under:
Try these examples:
Selecting an example fills the Input Textarea.
It does not immediately generate until you submit.
Generation requires non-whitespace Input.
Current shared message:
Input required
with:
“Please enter a prompt to continue.”
The generated response appears progressively.
Technical content—including fenced Code Blocks—can be rendered through the shared Markdown presentation.
The Output Header includes Copy.
The Output Header includes Download.
All Standard ToolPage downloads use:
.txt
regardless of the logical type of generated content.
The current pattern is:
[tool-id]-output.txt
Therefore:
.md.yaml.yml.env Template does not automatically download as .env.gitignoreRename/copy the content into the appropriate file after review.
Standard ToolPage Output is not directly editable.
There is no persistent Save function.
There is no persistent generation-history list.
Reset returns the current Tool to a clean Input/Output state, subject to the shared streamed-state behavior documented in Chapter 12.
Standard Development Tools use the subscriber's current selected AI Model through the shared stream.
Configured subscriber AI provider Keys can be forwarded through the same shared generation architecture.
Standard ToolPage calculates Base Cost using this priority:
When Standard ToolPage identifies the selected Model as OpenAI, its displayed cost uses the shared 1.5× Base Cost multiplier, rounded upward.
| ToolCurrent Base Reference | |
| SQL Builder | 15 Tokens |
| Bug Fix | 20 Tokens |
| Code Review | 25 Tokens |
| API Docs | 30 Tokens |
| README | 20 Tokens |
| Regex | 10 Tokens |
| Unit Tests | 20 Tokens |
| OCR Tool | 15 Tokens |
| Cron Builder | 20 Tokens catalogue reference |
| Docker Compose | 20 Tokens catalogue reference |
.env Template | 20 Tokens catalogue reference |
| Git Ignore | 20 Tokens catalogue reference |
The primary Development catalogue lists SQL, Bug Fix, Code Review, API Docs, README, Regex, Unit Tests, and OCR at their respective values.
The newer shared catalogue entries assign Cron, Docker Compose, .env Template, and Git Ignore 20 Tokens each.
| ToolRoute FallbackCatalogue | ||
| Cron Builder | 10 | 20 |
| Docker Compose | 15 | 20 |
.env Template | 10 | 20 |
| Git Ignore | 5 | 20 |
The catalogue currently has higher ToolPage precedence than the route fallback.
For Standard Development Tools, if the live interface displays a different amount from this manual, use the amount currently displayed by PROS SUITE.
SQL Builder and OCR Tool do not expose the Standard ToolPage Token display.
Their catalogue values should therefore be treated as current reference amounts rather than immutable guarantees.
| ToolSpecializedStandard ToolPage | ||
| SQL Builder | Yes | No |
| Bug Fix | No | Yes |
| Code Review | No | Yes |
| API Docs | No | Yes |
| README | No | Yes |
| Regex | No | Yes |
| Unit Tests | No | Yes |
| OCR | Yes | No |
| Cron Builder | No | Yes |
| Docker Compose | No | Yes |
.env Template | No | Yes |
| Git Ignore | No | Yes |
| ToolCopyDownloadEdit | |||
| SQL Builder | Yes | No | Yes |
| Bug Fix | Yes | TXT | No |
| Code Review | Yes | TXT | No |
| API Docs | Yes | TXT | No |
| README | Yes | TXT | No |
| Regex | Yes | TXT | No |
| Unit Tests | Yes | TXT | No |
| OCR | Yes | No | No |
| Cron Builder | Yes | TXT | No |
| Docker Compose | Yes | TXT | No |
.env Template | Yes | TXT | No |
| Git Ignore | Yes | TXT | No |
| FunctionExecuted by Chapter 36 Tool? | |
| Run SQL against database | No |
| Run submitted code | No |
| Modify repository code | No |
| Run security scan | No |
| Test an API | No |
| Commit README | No |
| Execute Regex | No |
| Run Unit Tests | No |
| Extract text from uploaded Image | Yes, AI operation |
| Install Cron Job | No |
| Launch Docker Containers | No |
| Configure environment variables | No |
Modify .gitignore | No |
If known, include:
in the Query Description.
Select the correct Database Type whenever possible.
For large datasets, mention:
Never blindly execute generated:
against production data.
Use development/staging environments for verification when appropriate.
Include enough surrounding code for context without unnecessarily exposing an entire proprietary codebase.
Explain exactly how the problem occurs.
This helps distinguish a code defect from a misunderstanding of requirements.
Remove:
before pasting Code unless absolutely necessary and handled appropriately.
AI-generated code should pass your own:
before production deployment.
Do not allow AI to guess endpoints that do not exist.
Document actual:
Do not publish invented authentication instructions.
If generating OpenAPI/Swagger content, pass the result through an appropriate external validator before publishing.
Supply the commands your project actually uses.
Include accurate:
If the project has no declared License, do not allow AI to assign one without authorization.
Since Standard ToolPage downloads .txt, verify formatting after transferring the content into README.md.
Provide strings that must match.
Provide strings that must not match.
Always identify the Regex implementation when portability matters.
Validate against:
Poorly designed patterns can cause expensive backtracking.
Test generated Regex against realistic data before production use.
The AI needs the actual function/class/component to generate meaningful Tests.
Avoid ambiguity around testing APIs.
Explicitly request:
Ensure generated Mocks represent actual dependencies and behavior.
Generated code is only a draft until your test runner executes it successfully.
Clear Images improve text extraction.
Focus the Image on the text area where possible.
Remember that OCR sends the Image content through the AI-generation pathway.
Avoid uploading confidential material unless appropriate for your organization's policies.
Pay particular attention to:
where a single OCR error could matter.
Include it in the Prompt whenever the schedule depends on local time.
Linux Cron and other scheduling systems can differ.
Use the appropriate scheduler's own validation/testing tools.
Avoid relying blindly on ambiguous or floating Tags for production.
Use proper environment/secret management instead of embedding sensitive credentials.
Confirm data survives expected Container lifecycle operations.
Do not expose unnecessary Ports publicly.
Run and validate the generated Compose configuration before production deployment.
.env TemplateA Template should document required Variables without exposing secrets.
Ask the Tool to provide inline comments explaining:
.env.example Safe to CommitDo not put real credentials in a file intended for source control.
Include:
Verify that sensitive local files are excluded where appropriate.
Review broad patterns before committing the generated .gitignore.
Enter a Query Description.
Select the correct Database Type and regenerate.
The Tool cannot inspect your schema.
Supply actual Table and Column names in your Prompt.
That can occur in the current implementation because the full AI response is stored as sqlQuery.
Use Edit mode to isolate the desired SQL before copying.
Execution is not part of SQL Builder.
Use your database-management environment after review.
Enter non-whitespace content in the Prompt.
Supply more technical context, including:
Standard ToolPage uses text input rather than a source-file upload workflow.
Standard ToolPage Output is read-only presentation.
Copy the result into your editor.
Code execution is not part of these Standard Development pages.
No universal persistent generation history exists.
Standard ToolPage always downloads .txt.
Rename or transfer the content into the appropriate file type after validation.
The current file input accepts Images only.
DOCX is not supported by this OCR page.
Ensure the selected file is recognized by the browser as an Image MIME type.
Use a clearer Image and manually verify important text.
No OCR Edit Tab exists.
Copy the text into another editor.
The current OCR workspace supports Copy but not Download.
That is consistent with the current source.
The route fallback is 10, but the higher-priority catalogue assigns 20.
The current catalogue value of 20 overrides the 15-Token route fallback unless live settings specify another amount.
.env Template Shows 20 Instead of 10The shared catalogue currently assigns 20.
Likewise, the current catalogue assigns 20 despite the route's 5-Token fallback.
README.md..env Template Checklist.env/secret files reviewed.The source verifies:
It does not establish:
.sql DownloadThe source verifies:
It does not establish:
The source verifies:
It does not establish:
The source verifies:
It does not establish:
The source verifies:
It does not establish:
.md DownloadThe source verifies:
It does not establish:
The source verifies:
It does not establish:
The source verifies:
image/* validationIt does not establish:
The source verifies:
It does not establish:
The source verifies:
It does not establish:
.yml Download.env Template Currently SupportsThe source verifies:
.env Template Does Not Currently EstablishIt does not establish:
.env installation.env DownloadThe source verifies:
.gitignore generationIt does not establish:
.gitignore installation.gitignore DownloadA strong operating workflow across Chapter 36 is:
Define the Technical Requirement
→ Select the Correct Development Tool
→ Supply Accurate Language/Framework/Database Context
→ Remove Sensitive Secrets
→ Generate the Technical Output
→ Review the AI Explanation
→ Copy or Download the Result
→ Move It Into the Appropriate Development Environment
→ Validate With Native Tooling
→ Run Tests
→ Review Security and Performance
→ Test in Development/Staging
→ Deploy Only After Verification
For example:
SQL Builder → Database client → Review → Test → Execute
Bug Fix → Source editor → Build/Test → QA
Code Review → Developer review → Static analysis/Test suite
API Docs → API specification validator → Documentation system
README → README.md → Repository
Regex → Native Regex tester/application tests
Unit Tests → Test files → Test runner/CI
OCR → Proofread extracted text → Destination document/system
Cron Builder → Scheduler validator → Crontab/platform scheduler
Docker Compose → .yml file → docker compose config → Staging
.env Template → .env.example → Secure secret-management workflow
Git Ignore → .gitignore → Git review
AIUNIFY PROS SUITE's Development category combines twelve tools covering database query generation, debugging, code review, API documentation, project documentation, Regex creation, Unit Tests, OCR, Cron expressions, Docker Compose, Environment Templates, and Git Ignore generation.
Two tools use specialized interfaces.
AI SQL Builder accepts natural-language Query requirements and an optional choice among MySQL, PostgreSQL, SQLite, SQL Server, and Oracle. It asks the AI for optimized SQL, an explanation, and assumptions about the Table structure. It provides Preview and Edit modes plus Copy SQL. However, the current client stores the entire AI response as sqlQuery; consequently, the visible, generated, and copied result can contain SQL together with explanations and assumptions rather than an isolated executable Query.
SQL Builder does not connect to or execute against a database, inspect schemas, return live rows, or validate the generated statement using a database engine.
AI OCR Tool accepts Images, displays a Preview, converts the selected Image to Base64, and automatically submits it through AIUNIFY's streaming AI workflow for text extraction. The interface visibly advertises JPG, PNG, GIF, and WebP and technically uses image/*. Despite the page description mentioning “documents,” the current file picker does not accept PDF or DOCX files.
OCR output is streamed into Extracted Text and can be copied, but the current workspace does not provide Edit, Download, multi-page processing, batch upload, or persistent OCR history.
The remaining ten Development tools use Standard ToolPage. Consequently, they share the common:
Prompt → Generate → Streaming Output → Copy/Download
workflow.
The Download action creates a .txt file regardless of the logical technical format. This means generated README, OpenAPI, Unit Test, Docker Compose, .env, and .gitignore content must be transferred or renamed into their appropriate native files before use.
Four current-version Token discrepancies deserve particular attention:
The shared feature catalogue assigns all four 20 Tokens. Because Standard ToolPage prioritizes the feature catalogue over the route fallback, 20 Tokens is their current default base reference unless a live AI-limit configuration overrides it.
The central operating principle for Chapter 36 is:
AIUNIFY PROS SUITE can accelerate technical creation, debugging, documentation, testing preparation, and configuration generation—but generated technical output should be reviewed and validated with the native development, testing, database, security, and deployment tools responsible for actually running it.