> ## Documentation Index
> Fetch the complete documentation index at: https://docs.runable.com/llms.txt
> Use this file to discover all available pages before exploring further.
# AI Limitations
> Understand what AI can and can't do, why unexpected results happen, and how to get the best possible outcomes.
# AI Limitations
Runable uses state-of-the-art AI models to help you build websites, applications, videos, documents, presentations, images, and more.
While AI can dramatically accelerate development, it isn't perfect.
Understanding its strengths and limitations will help you achieve better results with fewer retries.
***
# AI Isn't Deterministic
The same prompt may generate slightly different results each time.
This is expected behavior.
AI does not execute predefined templates—it reasons about your request and generates a new response each time.
***
# AI Can Misinterpret Prompts
The AI only understands what you tell it.
If a prompt is too vague, it has to make assumptions.
Example:
❌
```text theme={null}
Improve my website.
```
Better:
```text theme={null}
Improve only the homepage.
Do not modify authentication.
Keep branding unchanged.
Improve typography and spacing only.
```
***
# AI Can Hallucinate
Sometimes AI confidently generates information that is incorrect or incomplete.
Examples include:
* Incorrect explanations
* Wrong code
* Fake API responses
* Incorrect assumptions
* Missing logic
* Unsupported implementations
Always review AI-generated output before using it in production.
Never rely on AI-generated output for legal, financial, medical, or other high-risk decisions without independent verification.
***
# Large Changes Increase Risk
AI performs best when making focused changes.
Large prompts such as:
```text theme={null}
Rewrite my whole application.
```
increase the chance of:
* unrelated changes
* regressions
* broken layouts
* inconsistent architecture
Instead:
* improve one page
* one feature
* one component
* one API
* one screen
at a time.
***
# Code Generation Isn't Perfect
AI-generated code may contain:
* bugs
* lint issues
* unsupported libraries
* build failures
* incorrect imports
* outdated packages
Always:
* review code
* run tests
* verify builds
* check production before deployment
***
# Existing Projects Can Become Complex
As projects grow larger:
* dependencies increase
* architecture becomes more complex
* context grows
* more files are involved
Large projects generally require:
* smaller prompts
* incremental changes
* more frequent testing
***
# AI Doesn't Know Your Intent
The AI only knows:
* what you type
* uploaded files
* available project context
It cannot read your mind.
Always explain:
* your goal
* expected result
* constraints
* what should remain unchanged
***
# AI May Need Multiple Iterations
Not every request will be perfect on the first attempt.
Professional teams commonly iterate several times to achieve the desired outcome.
Instead of starting over, refine your prompt and build on previous results.
***
# Video Generation Limitations
Video generation is one of the most computationally intensive features available.
Current AI models may occasionally:
* misrender text
* generate incorrect typography
* miss small visual details
* produce inconsistent character appearances
* require multiple iterations
For best results:
* avoid large amounts of on-screen text
* keep instructions specific
* describe the desired style clearly
***
# Image Generation Limitations
Image generation may occasionally:
* misunderstand object placement
* ignore small details
* alter colors
* misread text
* produce inconsistent faces
Uploading reference images significantly improves results.
***
# AI Doesn't Always Choose the Best Library
For coding projects, AI may occasionally choose:
* deprecated libraries
* unsupported packages
* inefficient implementations
If your project requires a specific framework or package, include it explicitly in your prompt.
Example:
```text theme={null}
Use React Router.
Do not use Next.js routing.
Use Tailwind CSS.
Use TypeScript.
```
***
# Credit Usage
AI consumes credits based on the work required.
Tasks requiring more reasoning or computation generally consume more credits.
Examples include:
* Video generation
* Large code changes
* Complex research
* Multi-file refactoring
* High-resolution image generation
***
# Best Practices
The more context you provide, the better the AI understands your project.
Smaller prompts usually produce more reliable results.
Always verify AI-generated output before publishing.
Reference images and examples significantly improve results.
Tell the AI exactly what should remain unchanged.
Improve previous results instead of restarting every time.
***
# Frequently Asked Questions
The prompt may have been too broad.
Limit the scope by specifying exactly which files or features should be modified.
Very large or resource-intensive tasks may require multiple iterations or additional credits.
Breaking the work into smaller steps often produces better results.
AI predicts likely solutions based on patterns.
Like a human developer, it can occasionally make mistakes and should always be reviewed.
AI is designed to accelerate development, not replace engineering judgment.
Reviewing, testing, and validating outputs remains an important part of the development process.
***
# Summary
AI is an incredibly powerful development partner, but it works best when you:
* provide detailed prompts
* make focused requests
* review generated output
* iterate on results
* understand its current limitations
Doing so will help you build faster, reduce unnecessary retries, and get the most out of Runable.
***
## Related Guides
* Prompt Engineering Guide
* Image Generation
* How Credits Work
* Understanding Credit Usage
* Common Mistakes