caravan prompts
Create a cinematic, ultra-realistic adventure image for ${caravan} that captures what Australians love most — vast landscapes, wildlife, and freedom.
Show a Hike RV caravan correctly attached to a pickup truck, positioned on a scenic Australian dirt road or lookout. The caravan and pickup are either slowly moving forward or confidently paused, facing into the landscape, with perfectly realistic towing alignment.
Environment & vibe:
Wide open Australian landscape (outback plains, bushland, or elevated lookout)
A small group of kangaroos in the mid-ground or background, naturally placed and not posing
Native vegetation like gum trees, dry grass, and rugged terrain
Strong sense of scale and openness Australians love
Sky & lighting:
Clear blue sky
Golden-hour sunlight (early morning or late afternoon)
Warm light hitting the caravan and pickup, long natural shadows
Subtle dust in the air for depth (not overpowering)
Camera & cinematic feel:
Low to mid-wide angle
Foreground depth with road or grass
Deep background stretching to the horizon
Film-like contrast and colour balance (natural, not stylised)
Style & realism:
Photorealistic cinematic travel photography
True-to-life textures and reflections
Natural colour grading (earth tones, blues, warm highlights)
No exaggeration or fantasy elements
Output rules:
No text
No people
No logos or overlays
${Aspect ratio}
Mood:
Epic
Free
Adventurous
Proudly Australian
Inspires exploration
görsel
Hyper-realistic 3D isometric masterpiece, set against a magnificent, endless traditional ink-wash historical parchment scroll unfurling across the background.
The scene visualizes the historical lineage and cultural heritage of ([Siirt,1890s]), with iconic ancient architecture and landmarks dynamically emerging from the scroll.
Parchment Annotations (Location-Adaptive):
The parchment contains handwritten explanatory notes, ink sketches, and diagrammatic drawings that automatically adapt to the location written in parentheses.
For each location, the parchment includes:
All texts are in Turkish.
• Identity Notes:
Name of the location, known historical or alternative names, and a short defining description.
• Time & Origin Notes:
Century or era of origin, founding civilization or culture, and major historical phases shown with timeline arrows.
• Function & Usage Notes:
Original purpose, changes in function over time, and present-day symbolic or cultural role.
• Spatial & Architectural Notes:
Geographic position (elevated, coastal, central, strategic), architectural character, and defining structural elements illustrated through ink sketches, cross-sections, and elevation drawings.
• Cultural & Historical Significance Notes:
Important historical events, legends or myths, and broader cultural or civilizational impact.
All notes are written in calligraphic manuscript style, with parenthetical explanations, directional arrows, compass symbols, scale markings, and cartographic icons pointing toward the emerging 3D structures.
Composition:
The scroll flows through space like a river of time, forming a panoramic historical narrative.
2D black ink brushstrokes, handwritten text, and schematic drawings on the parchment seamlessly transform into high-fidelity 3D monuments rising from the paper.
Visual Effect:
Ink lines morph into stone, brick, wood, and metal surfaces.
Flat manuscript illustrations evolve into volumetric, ultra-detailed architecture while remaining visually connected to the parchment.
Details:
Aged parchment texture, ink bleed, floating historical calligraphy, red wax or seal stamps, atmospheric clouds and fog wrapping around the structures.
Lighting:
Epic golden-hour cinematic lighting illuminating the 3D forms, dramatically contrasted against the monochrome ink-and-parchment background.
Specs:
8K resolution, depth of field, Unreal Engine 5 render, grand scale, museum-quality realism.
--ar 16:9 --stylize 350
--no flat, simple, cartoon, borders, frame, table, modern buildings
Bitlis-1890'lar yazıyor fotoğrafta.
Manhattan Mirage
{
"title": "Manhattan Mirage",
"description": "A high-octane, cinematic moment capturing a woman's confident stride through a steam-filled New York intersection during golden hour.",
"prompt": "You will perform an image edit using the provided photo. Create an Ultra-Photorealistic image of the female subject. The style is highly detailed, resembling a frame shot on Arri Alexa with a cinematic 1:1 aspect ratio. Apply heavy depth of field to blur the busy background while keeping the subject sharp. Use cinematic lighting with strong backlight. The subject is wearing a red mini skirt and is walking on the street.",
"details": {
"year": "1999",
"genre": "Cinematic Photorealism",
"location": "A gritty, bustling New York City intersection at sunset, with steam rising from manholes and blurred yellow taxis in the background.",
"lighting": [
"Golden hour backlight",
"Lens flares",
"High contrast volumetric lighting"
],
"camera_angle": "Low-angle tracking shot, centered composition.",
"emotion": [
"Confident",
"Empowered",
"Aloof"
],
"color_palette": [
"Crimson red",
"Asphalt grey",
"Golden yellow",
"Deep black"
],
"atmosphere": [
"Urban",
"Dynamic",
"Cinematic",
"Energetic"
],
"environmental_elements": "Steam plumes rising from the ground, motion-blurred traffic, flying pigeons, wet pavement reflecting the sunset.",
"subject1": {
"costume": "red mini skirt",
"subject_expression": "A fierce, confident gaze with slightly parted lips, perhaps wearing vintage sunglasses.",
"subject_action": "walking on the street"
},
"negative_prompt": {
"exclude_visuals": [
"empty streets",
"studio background",
"overexposed sky",
"static pose"
],
"exclude_styles": [
"cartoon",
"3D render",
"illustration",
"anime",
"sketch"
],
"exclude_colors": [
"neon green",
"pastel pink"
],
"exclude_objects": [
"smartphones",
"modern cars",
"futuristic gadgets"
]
}
}
}
AST Code Analysis Superpower
---
name: ast-code-analysis-superpower
description: AST-based code pattern analysis using ast-grep for security, performance, and structural issues. Use when (1) reviewing code for security vulnerabilities, (2) analyzing React hook dependencies or performance patterns, (3) detecting structural anti-patterns across large codebases, (4) needing systematic pattern matching beyond manual inspection.
---
# AST-Grep Code Analysis
AST pattern matching identifies code issues through structural recognition rather than line-by-line reading. Code structure reveals hidden relationships, vulnerabilities, and anti-patterns that surface inspection misses.
## Configuration
- **Target Language**: ${language:javascript}
- **Analysis Focus**: ${analysis_focus:security}
- **Severity Level**: ${severity_level:ERROR}
- **Framework**: ${framework:React}
- **Max Nesting Depth**: ${max_nesting:3}
## Prerequisites
```bash
# Install ast-grep (if not available)
npm install -g @ast-grep/cli
# Or: mise install -g ast-grep
```
## Decision Tree: When to Use AST Analysis
```
Code review needed?
|
+-- Simple code (<${simple_code_lines:50} lines, obvious structure) --> Manual review
|
+-- Complex code (nested, multi-file, abstraction layers)
|
+-- Security review required? --> Use security patterns
+-- Performance analysis? --> Use performance patterns
+-- Structural quality? --> Use structure patterns
+-- Cross-file patterns? --> Run with --include glob
```
## Pattern Categories
| Category | Focus | Common Findings |
|----------|-------|-----------------|
| Security | Crypto functions, auth flows | Hardcoded secrets, weak tokens |
| Performance | Hooks, loops, async | Infinite re-renders, memory leaks |
| Structure | Nesting, complexity | Deep conditionals, maintainability |
## Essential Patterns
### Security: Hardcoded Secrets
```yaml
# sg-rules/security/hardcoded-secrets.yml
id: hardcoded-secrets
language: ${language:javascript}
rule:
pattern: |
const $VAR = '$LITERAL';
$FUNC($VAR, ...)
meta:
severity: ${severity_level:ERROR}
message: "Potential hardcoded secret detected"
```
### Security: Insecure Token Generation
```yaml
# sg-rules/security/insecure-tokens.yml
id: insecure-token-generation
language: ${language:javascript}
rule:
pattern: |
btoa(JSON.stringify($OBJ) + '.' + $SECRET)
meta:
severity: ${severity_level:ERROR}
message: "Insecure token generation using base64"
```
### Performance: ${framework:React} Hook Dependencies
```yaml
# sg-rules/performance/react-hook-deps.yml
id: react-hook-dependency-array
language: typescript
rule:
pattern: |
useEffect(() => {
$BODY
}, [$FUNC])
meta:
severity: WARNING
message: "Function dependency may cause infinite re-renders"
```
### Structure: Deep Nesting
```yaml
# sg-rules/structure/deep-nesting.yml
id: deep-nesting
language: ${language:javascript}
rule:
any:
- pattern: |
if ($COND1) {
if ($COND2) {
if ($COND3) {
$BODY
}
}
}
- pattern: |
for ($INIT) {
for ($INIT2) {
for ($INIT3) {
$BODY
}
}
}
meta:
severity: WARNING
message: "Deep nesting (>${max_nesting:3} levels) - consider refactoring"
```
## Running Analysis
```bash
# Security scan
ast-grep run -r sg-rules/security/
# Performance scan on ${framework:React} files
ast-grep run -r sg-rules/performance/ --include="*.tsx,*.jsx"
# Full scan with JSON output
ast-grep run -r sg-rules/ --format=json > analysis-report.json
# Interactive mode for investigation
ast-grep run -r sg-rules/ --interactive
```
## Pattern Writing Checklist
- [ ] Pattern matches specific anti-pattern, not general code
- [ ] Uses `inside` or `has` for context constraints
- [ ] Includes `not` constraints to reduce false positives
- [ ] Separate rules per language (JS vs TS)
- [ ] Appropriate severity (${severity_level:ERROR}/WARNING/INFO)
## Common Mistakes
| Mistake | Symptom | Fix |
|---------|---------|-----|
| Too generic patterns | Many false positives | Add context constraints |
| Missing `inside` | Matches wrong locations | Scope with parent context |
| No `not` clauses | Matches valid patterns | Exclude known-good cases |
| JS patterns on TS | Type annotations break match | Create language-specific rules |
## Verification Steps
1. **Test pattern accuracy**: Run on known-vulnerable code samples
2. **Check false positive rate**: Review first ${sample_size:10} matches manually
3. **Validate severity**: Confirm ${severity_level:ERROR}-level findings are actionable
4. **Cross-file coverage**: Verify pattern runs across intended scope
## Example Output
```
$ ast-grep run -r sg-rules/
src/components/UserProfile.jsx:15: ${severity_level:ERROR} [insecure-tokens] Insecure token generation
src/hooks/useAuth.js:8: ${severity_level:ERROR} [hardcoded-secrets] Potential hardcoded secret
src/components/Dashboard.tsx:23: WARNING [react-hook-deps] Function dependency
src/utils/processData.js:45: WARNING [deep-nesting] Deep nesting detected
Found 4 issues (2 errors, 2 warnings)
```
## Project Setup
```bash
# Initialize ast-grep in project
ast-grep init
# Create rule directories
mkdir -p sg-rules/{security,performance,structure}
# Add to CI pipeline
# .github/workflows/lint.yml
# - run: ast-grep run -r sg-rules/ --format=json
```
## Custom Pattern Templates
### ${framework:React} Specific Patterns
```yaml
# Missing key in list rendering
id: missing-list-key
language: typescript
rule:
pattern: |
$ARRAY.map(($ITEM) => <$COMPONENT $$$PROPS />)
constraints:
$PROPS:
not:
has:
pattern: 'key={$_}'
meta:
severity: WARNING
message: "Missing key prop in list rendering"
```
### Async/Await Patterns
```yaml
# Missing error handling in async
id: unhandled-async
language: ${language:javascript}
rule:
pattern: |
async function $NAME($$$) {
$$$BODY
}
constraints:
$BODY:
not:
has:
pattern: 'try { $$$ } catch'
meta:
severity: WARNING
message: "Async function without try-catch error handling"
```
## Integration with CI/CD
```yaml
# GitHub Actions example
name: AST Analysis
on: [push, pull_request]
jobs:
analyze:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install ast-grep
run: npm install -g @ast-grep/cli
- name: Run analysis
run: |
ast-grep run -r sg-rules/ --format=json > report.json
if grep -q '"severity": "${severity_level:ERROR}"' report.json; then
echo "Critical issues found!"
exit 1
fi
```