Dev.to AI πŸ€– Ai πŸ‘ 0 πŸ“– 20 min read

AI image generation as an auditable Git workflow

In short: Request images in a Gitea issue, let ai-git-bot generate them with fal.ai through MCP, and review the result as a pull request. Every image ends up versioned in Git, linked to the issue that requested it, and t

AI image generation as an auditable Git workflow

In short: Request images in a Gitea issue, let ai-git-bot generate them with fal.ai through MCP, and review the result as a pull request. Every image ends up versioned in Git, linked to the issue that requested it, and traceable to who asked for it, when, with which prompt and model β€” and from which source URL, recorded automatically in the commit.

Table of contents

  1. Why Git for images?
  2. How it works
  3. Prerequisites
  4. Step 1 – Prepare the repository
  5. Step 2 – Create the image-generation workflow
  6. Step 3 – Create a dedicated tool set
  7. Step 4 – Add the fal.ai MCP configuration
  8. Step 5 – Create the bot
  9. Step 6 – Request images with an issue
  10. Step 7 – Review and merge the pull request
  11. Bonus – Using a reference image (e.g. your face)
  12. Tips, troubleshooting and next steps

1. Why Git for images?

ai-git-bot is usually seen as a tool for developers who manage code, or for engineers who maintain documentation, circuit plans and other text-based data. But the workflow behind it β€” issue β†’ bot β†’ pull request β†’ review β†’ merge β€” has nothing specific to text. With the file-transfer tools download-file, upload-file and file-info, it works just as well for binary assets such as images.

Typical situation: for campaigns, presentations, newsletters or social media you constantly need teaser images, title images, backgrounds and variations. These often end up scattered across chat histories, download folders and personal drives β€” nobody knows later who created which image, with which prompt, or for what purpose.

With a Git-based process you get:

Requirement How Git + ai-git-bot covers it
Who requested an image? Issue author
When was it generated? Commit and PR timestamps
Why / for which purpose? Issue description
How was it generated? Prompt, model and seed in a README next to each image
Where does the file come from? Asset-Source commit trailer with source URL and SHA-256
Who approved it? PR review and merge
Where is the final file? One central, versioned repository
flowchart LR
    subgraph Before["❌ Without a process"]
        A1[Chat with an image AI] --> A2[Download folder]
        A2 --> A3[Email / Teams / USB stick]
        A3 --> A4["Who made this? Which prompt?<br/>Is this the final version?"]
    end

    subgraph After["βœ… With ai-git-bot"]
        B1[Issue = request] --> B2[Bot generates images]
        B2 --> B3[Pull request = review]
        B3 --> B4[Merge = approved asset<br/>with full history]
    end

2. How it works

The agent's usual file tool, write-file, writes text only: tool arguments are JSON strings, and JSON strings can't carry raw bytes. And the image data would have to pass through the language model β€” millions of characters per image.

download-file solves this on the server side: the model only passes the URL that fal.ai returned, and the ai-git-bot server fetches the bytes and writes them into the workspace. The model only ever sees the path, size, MIME type and SHA-256. upload-file does the same in the other direction, for reference images (see the bonus section).

3. Prerequisites

  • A running ai-git-bot instance with the file-transfer tools download-file, upload-file and file-info (see the project's doc/FILE_TRANSFER.md).
  • A Gitea instance with a user/token for the bot.
  • An existing AI integration (your LLM provider) and Git integration (your Gitea connection) in ai-git-bot.
  • A fal.ai account with an API key from fal.ai/dashboard/keys. The key has the form key_id:key_secret.

πŸ’‘ Why fal.ai? ai-git-bot connects to remote MCP servers using a static token or custom headers β€” it does not run browser-based OAuth logins. fal.ai's MCP server accepts an API key in a header, so it works without any extra bridge.

Configure ai-git-bot

Two things go into the environment of the ai-git-bot service in your docker-compose.yml: the fal.ai key, and the allowlists for the file-transfer tools. Both tools are disabled until their allowlists are set.

services:
  ai-git-bot:
    environment:
      # fal.ai API key, referenced as ${env:FAL_KEY} in the MCP configuration
      GITEABOT_SECRET_ENV_WHITELIST: FAL_KEY
      FAL_KEY: ${FAL_KEY:-}

      # download-file: where images may come from and where they may go
      AGENT_FILE_TRANSFER_DOWNLOAD_ALLOWED_HOSTS: fal.media,*.fal.media
      AGENT_FILE_TRANSFER_DOWNLOAD_ALLOWED_PATHS: images/**
      AGENT_FILE_TRANSFER_DOWNLOAD_ALLOWED_CONTENT_TYPES: image/png,image/jpeg,image/webp

      # upload-file: only needed for reference images (see the bonus section)
      # AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_HOSTS: <host of fal.ai's upload URL>
      # AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_PATHS: references/**

Put FAL_KEY=<key_id>:<key_secret> in your .env file (never in Git) and restart the container.

Setting Why
fal.media,*.fal.media fal.ai serves generated files from fal.media and subdomains such as v3.fal.media. A wildcard matches subdomains only, so the apex host is listed separately.
images/** Downloads can only land in the images/ folder β€” never next to your scripts.
image/png,image/jpeg,image/webp The type is detected from the file's bytes, not the server's header. An HTML error page is refused even if the URL ends in .png.

πŸ”’ The tools are built for hostile input: HTTPS only, no internal or cloud-metadata addresses, every redirect re-checked, size limits enforced while streaming, nothing inside .git/. Query strings of URLs (which may contain credentials) are never logged or shown to the model.

Step 1 – Prepare the repository

We start with an empty repository in Gitea that contains just one file: validate.sh.

Why do we need validate.sh? In ai-git-bot, every change to the workspace has to be followed by a validation step before the bot opens a pull request β€” for code, that would be a build or a test run. Downloading an image is a workspace change too. For an image repository, the validation is a committed script that the bot runs with the execute tool.

The simplest possible script just succeeds:

#!/usr/bin/env bash
exit 0

That is enough to get started. But since the script runs before every pull request anyway, it can also act as a quality gate. This version checks the folder conventions, that each file really is the image type its extension claims, and that every image is documented:

#!/usr/bin/env bash
# Validates the image folders under images/.
# Downloads are done by the bot's download-file tool, so this script only checks.
set -euo pipefail
shopt -s nullglob

MAX_BYTES=$((25 * 1024 * 1024))
errors=0
fail() { echo "ERROR: $*"; errors=$((errors + 1)); }

# First 12 bytes of a file as lowercase hex
magic() { od -An -tx1 -N12 "$1" | tr -d ' \n'; }

dirs=(images/*/)
[ ${#dirs[@]} -gt 0 ] || { echo "ERROR: no image folders found under images/"; exit 1; }

images_total=0
for dir in "${dirs[@]}"; do
  dir=${dir%/}
  name=$(basename "$dir")

  # Folder naming: <issue-number>-<short-slug>
  [[ "$name" =~ ^[0-9]+-[a-z0-9]+(-[a-z0-9]+)*$ ]] \
    || fail "$dir: folder name must look like <issue-number>-<short-slug>"

  readme="$dir/README.md"
  [ -f "$readme" ] || fail "$dir: README.md is missing"

  images_in_dir=0
  for file in "$dir"/* "$dir"/.[!.]*; do
    [ -e "$file" ] || continue
    base=$(basename "$file")
    [ "$base" = "README.md" ] && continue

    if [ -d "$file" ]; then fail "$file: subfolders are not allowed"; continue; fi
    if [ -L "$file" ]; then fail "$file: symlinks are not allowed"; continue; fi

    # File naming: <two-digit-index>-<style>.<ext>
    [[ "$base" =~ ^[0-9]{2}-[a-z0-9]+(-[a-z0-9]+)*\.(png|jpg|jpeg|webp)$ ]] \
      || { fail "$file: name must look like 01-style.png (png, jpg, jpeg or webp)"; continue; }

    size=$(wc -c < "$file" | tr -d ' ')
    [ "$size" -gt 0 ] || { fail "$file: file is empty"; continue; }
    [ "$size" -le "$MAX_BYTES" ] || fail "$file: larger than $((MAX_BYTES / 1024 / 1024)) MB"

    # The content must match the extension (catches HTML error pages saved as .png)
    hex=$(magic "$file")
    case "${base##*.}" in
      png)      [[ "$hex" == 89504e470d0a1a0a* ]] || fail "$file: not a PNG file" ;;
      jpg|jpeg) [[ "$hex" == ffd8ff* ]]           || fail "$file: not a JPEG file" ;;
      webp)     [[ "$hex" == 52494646????????57454250 ]] || fail "$file: not a WebP file" ;;
    esac

    # Every image must be documented in the README
    if [ -f "$readme" ] && ! grep -qF "$base" "$readme"; then
      fail "$file: not mentioned in $readme"
    fi

    images_in_dir=$((images_in_dir + 1))
  done

  [ "$images_in_dir" -gt 0 ] || fail "$dir: contains no images"
  images_total=$((images_total + images_in_dir))
done

if [ "$errors" -gt 0 ]; then
  echo "Validation failed with $errors error(s)."
  exit 1
fi
echo "OK: $images_total image(s) in ${#dirs[@]} folder(s) are valid."

The script reports all problems at once, so the bot can fix them in one go. The bot can't weaken the checks either: execute only runs a script that is identical to the committed version.

Commit it with the executable bit

execute refuses scripts that aren't executable and never falls back to a shell interpreter (bash validate.sh is not an option).

On Linux or macOS, set the bit on the file itself. Git then records it in every later commit, and no git add can accidentally remove it:

chmod +x validate.sh
git add validate.sh
git commit -m "Add image validation script"
git push

On Windows, the file system has no executable bit, so set it in Git directly β€” after git add and before the commit:

git add validate.sh
git update-index --chmod=+x validate.sh
git commit -m "Add image validation script"
git push

Check what actually arrived on the server β€” the output must start with 100755:

git fetch
git ls-tree origin/main validate.sh
# 100755 blob 3f2a…    validate.sh

⚠️ ls -l is not a valid check: it shows the file on your disk, not the mode stored in Git. See Troubleshooting if the bot still reports "Validation script is not executable".

After the first image request, the repository will look like this:

flowchart TB
    root["πŸ“ campaign-images/"]
    root --> v["πŸ“„ validate.sh"]
    root --> img["πŸ“ images/"]
    img --> i42["πŸ“ 42-cybersecurity-ai-era/"]
    i42 --> f1["πŸ–ΌοΈ 01-cinematic.png"]
    i42 --> f2["πŸ–ΌοΈ 02-isometric.png"]
    i42 --> f3["πŸ–ΌοΈ …"]
    i42 --> meta["πŸ“„ README.md<br/>prompt, model, seed per image"]

Empty repository in Gitea

Step 2 – Create the image-generation workflow

In ai-git-bot, create a new workflow of type issue-generation (coding). This is the same workflow type developers use to turn an issue into a code change β€” we only swap the system prompt.

Create a new workflow

Replace the default system prompt with an image-specific one. Here is a template you can use as a starting point:

You are an image-generation assistant working in a Git repository. You turn image requests from issues into image files that are committed to the repository and delivered as a pull request.

## Your tools
- fal.ai MCP tools generate the images: `search_models`, `recommend_model`, `get_model_schema`, `run_model`, `check_job`, `get_job_result`, and `upload_file` for reference images.
- `download-file` stores a file from a URL in the repository.
- `file-info` and `upload-file` hand a repository file to fal.ai.
- `write-file` writes TEXT files only. Never use it for image data.
- `execute` runs the validation script `validate.sh`.

## Step 1 – Generate all images
- Find a suitable text-to-image model with `search_models` or `recommend_model`. Prefer fast, affordable models unless the issue asks for maximum quality.
- Call `get_model_schema` for the chosen model before generating, and only use input fields that exist in the schema.
- Generate with `run_model`. If it returns status "processing", poll with `check_job` until the status is COMPLETED, then fetch the output with `get_job_result`.
- NEVER call `run_model` again for an image that is still processing. Every call is a new, billable job.
- Generate exactly the number of images the issue asks for. If the issue does not say, generate one image.
- Generate ALL images before you change any file in the repository.

## Reference images (only if the issue asks for one)
- If the issue gives a public HTTPS URL, pass it unchanged as the image input of a model that supports reference or input images (check the field name with `get_model_schema`, usually `image_url`).
- If the issue names a file in the repository (e.g. `references/me.jpg`):
  1. `file-info` with the path β†’ size and MIME type.
  2. `upload_file` with `prepare_upload: true`, `file_name` and `file_size` β†’ `upload_url` and `file_url`.
  3. `upload-file` with the path and the `upload_url`.
  4. Use the `file_url` as the image input of the model.
- Never try to read binary files with `cat`.

## Step 2 – Store, document and validate (in ONE round)
Once every image has a URL, do all of the following in a single round:
1. `download-file` for each image:
   - target folder: `images/<issue-number>-<short-slug>/` (lowercase letters, digits and hyphens, e.g. `images/42-cybersecurity-ai-era/`)
   - file name: `<two-digit-index>-<style>.<ext>`, e.g. `01-cinematic.png`
   - `<ext>` must match the content type returned by fal.ai (`png`, `jpg` or `webp`).
2. `write-file` for `README.md` in that folder, with one section per image: file name, model (endpoint_id), full prompt, seed (if available) and image size. Source URLs and checksums are recorded automatically in the commit, so don't add them.
3. `execute` with the arguments `["validate.sh"]`.

`validate.sh` is the last step: once it passes, the run ends and the pull request is opened. If it fails, read the message, fix the problem (e.g. a missing README entry or a wrong file extension) and run it again. Only regenerate an image if the downloaded file itself is invalid.

## Pull request
- In the pull request description, list every image with its prompt and the model used, and reference the issue (e.g. "Closes #42").

πŸ’‘ Why one round at the end? For ai-git-bot, download-file and write-file change the workspace, and every workspace change needs a validation tool afterwards. When a validation round passes and the workspace contains changes, the bot considers the task done, commits and opens the pull request. Putting the downloads, the README and validate.sh into one final round gets everything into the same commit and doesn't waste validation attempts. The fal.ai URLs are temporary, so the downloads also shouldn't wait.

πŸ’‘ Optional – execute-code: a Python program in the sandbox may call MCP tools and read-only tools such as file-info, but not download-file, write-file or execute. That still helps: one program can run all generations including the polling β€” e.g. tools.call("mcp:fal:run_model", …) for each image β€” and return the image URLs in a single round. Check the exact tool names with tools.list().

✏️ Adjust the folder convention, preferred image sizes (e.g. 16:9 for slides) or a house style ("corporate colors: dark blue and teal") to your needs. If you change the folder or file naming, change validate.sh accordingly.

System prompt of the workflow

Step 3 – Create a dedicated tool set

Next, create a separate tool set for image generation so you don't change the behavior of your existing coding bots.

  • Validation: select execute. It runs the committed validate.sh.
  • download-file: select it. It is opt-in, so it is never part of the default tool set.
  • upload-file: select it only if you want to use reference images from the repository (see the bonus section). It is opt-in as well.
  • file-info: keep it. It's read-only and needed for reference-image uploads.
  • File tools (write-file, mkdir, …): keep them. The agent uses write-file for the README.md.
  • All other tools: leave as they are.
  • execute-code: optional (see the tip in Step 2).

Save the tool set under a descriptive name, e.g. image-generation.

ℹ️ If download-file or upload-file is shown as "Disabled until … is configured", the matching allowlist from the prerequisites is missing.

ℹ️ Results of validation tools are posted as comments. Every validate.sh run therefore leaves a short comment on the issue.

Tool set configuration

Step 4 – Add the fal.ai MCP configuration

Go to System settings β†’ MCP configurations and create a new entry, e.g. named fal-ai. Paste the following MCP declaration:

[
  {
    "name": "fal",
    "type": "url",
    "url": "https://mcp.fal.ai/mcp",
    "headers": { "Authorization": "Key ${env:FAL_KEY}" }
  }
]

⚠️ Use the headers field with the Key prefix. fal.ai expects Authorization: Key <key_id>:<key_secret> β€” a Bearer token is rejected.

Click Save and select tools. ai-git-bot connects to fal.ai, discovers all available tools and lets you choose which ones the agent may use. Because we want the agent to pick the model itself, select:

Tool Purpose Required?
search_models Find suitable models (e.g. category text-to-image) βœ…
recommend_model Get model suggestions for a described task Optional, helps choosing
get_model_schema Read the input fields of the chosen model βœ…
run_model Start a generation βœ…
check_job Poll a job that is still processing βœ…
get_job_result Fetch the finished image URL βœ…
upload_file Prepare the upload of a reference image Only for reference images
get_pricing Check cost before generating Optional, for cost control

Leave out search_docs and cancel_job β€” they are not needed for this use case.

flowchart LR
    S[search_models /<br/>recommend_model] --> M[get_model_schema]
    M --> R[run_model]
    R -->|completed| D[Image URL]
    R -->|processing| C[check_job]
    C -->|not finished| C
    C -->|COMPLETED| G[get_job_result]
    G --> D
    D --> DL["download-file<br/>(ai-git-bot)"]
    U[Reference image URL] -.->|optional:<br/>image_url input| R

MCP configuration with fal.ai

Tool selection for fal.ai

Step 5 – Create the bot

Now bring everything together. The AI integration (your LLM) and the Git integration (your Gitea connection) already exist β€” we reuse them.

flowchart LR
    W[Workflow<br/>image-generation prompt] --> Bot
    T[Tool set<br/>image-generation] --> Bot
    M[MCP configuration<br/>fal-ai] --> Bot
    A[AI integration<br/>existing] --> Bot
    G[Git integration<br/>existing] --> Bot
    Bot(("πŸ€– image-bot")) --> R[(campaign-images<br/>repository)]

Create a new bot, e.g. image-bot, and select:

  • Workflow: the image-generation workflow from Step 2
  • Tool set: image-generation from Step 3
  • MCP configuration: fal-ai from Step 4
  • AI integration: your existing one
  • Git integration: your existing Gitea integration
  • Repository: the image repository from Step 1

Existing AI and Git integrations

Bot configuration

Step 6 – Request images with an issue

Switch to Gitea and create a new issue in the image repository:

Title: Title images for "Cybersecurity in the AI Era"

Description:

Create 5 different title images for my presentation. The title of the presentation is "Cybersecurity in the AI Era".

Requirements:
- Every image in a different style.
- One image should be in a GTA-style illustration look.
- Format: 16:9 (for slides).

Then assign the issue to the bot. That's the trigger β€” from here on, the bot works on its own.

New issue in Gitea

Bot assigned to the issue

πŸ’‘ The issue is your audit record of the request: who asked, when, and with which requirements. Discussions about changes ("make image 3 brighter") can also happen as comments on the issue or the PR.

Step 7 – Review and merge the pull request

After a short while, the bot opens a pull request that contains the five new images and a README.md with prompt, model and seed for each image.

Bot activity on the issue

Pull request with the generated images

Files changed in the pull request

Provenance in the commit

The bot's commit carries one Asset-Source trailer per downloaded image: the repository path, the source URL and the SHA-256 of the file.

agent: implement #42 - Title images for "Cybersecurity in the AI Era"

Asset-Source: images/42-cybersecurity-ai-era/01-cinematic.png https://v3.fal.media/files/…/a1b2c3.png sha256:3f2a…
Asset-Source: images/42-cybersecurity-ai-era/02-isometric.png https://v3.fal.media/files/…/d4e5f6.png sha256:9c41…
…

These trailers are written by the ai-git-bot server from its own record of the downloads, not by the model β€” so they can't be forged or forgotten. URLs are stored without query strings, because those can contain credentials. A file that was downloaded and changed or deleted afterwards gets no trailer.

Read the provenance of all images later with:

git log --format='%h %(trailers:key=Asset-Source)'

Review

Review the images like you would review code:

  • βœ… Everything fine β†’ approve and merge. The images are now officially available in the main branch.
  • πŸ” Not happy with an image β†’ leave a comment in the PR or adjust the issue and let the bot run again.

The full audit trail is now in Gitea:

gitGraph
    commit id: "Add validate.sh"
    branch issue-42-title-images
    checkout issue-42-title-images
    commit id: "5 images + Asset-Source trailers"
    checkout main
    merge issue-42-title-images id: "Merge PR: approved by reviewer"

Bonus – Using a reference image (e.g. your face)

Many image models can take a reference image as input β€” for example, to put your own face into a title image, or to keep a product, logo or mascot consistent across a campaign. fal.ai models take the reference as a URL (usually an image_url input), so the image has to be somewhere fal.ai can reach.

There are two ways to get it there.

Option A – A public URL

If the image is already available under a public HTTPS URL (for example the raw link of a file in a public Gitea repository), just put that URL in the issue. The agent passes it to the model unchanged; nothing is uploaded.

Create 3 title images for "Cybersecurity in the AI Era". Use the person in this photo as the presenter shown in the images: https://gitea.example.com/marketing/campaign-images/raw/branch/main/references/my-portrait.jpg

Option B – A file in a private repository

For a private repository, the bot uploads the file to fal.ai itself with upload-file. The bytes go directly from the ai-git-bot server to fal.ai; the model only handles the upload URL.

How to set it up:

  1. Configure the upload allowlists for ai-git-bot (see prerequisites) and restart:
   AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_HOSTS: <host of fal.ai's upload URL>
   AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_PATHS: references/**

Both must be set β€” upload-file stays disabled otherwise. To find the host, look at the upload_url that fal.ai's upload_file tool returns with prepare_upload: true. Restricting the paths to references/** means the bot can never send anything else from the repository, even if an issue tries to make it.

  1. Enable upload-file in the tool set (Step 3) and upload_file in the MCP tool selection (Step 4).
  2. Commit the reference image, e.g. references/my-portrait.jpg.
  3. Mention it in the issue:
   Create 3 title images for "Cybersecurity in the AI Era". Use references/my-portrait.jpg as the presenter shown in the images.

The system prompt from Step 2 already contains the upload steps.

⚠️ Please note:

  • upload-file never sends files under .git/ or files ignored by .gitignore, and only follows redirects to the same host.
  • A public URL (option A) means anyone who knows it can see the image. Only publish what you are comfortable sharing.
  • Only use photos of people who have agreed to it, and remember that reference images are processed by an external service.

Tips, troubleshooting and next steps

Tips

  • Control costs: enable get_pricing and add a rule to the system prompt such as "Do not use models that cost more than $0.05 per image without asking in the issue."
  • Consistent results: define preferred formats, color palettes or a house style directly in the system prompt.
  • Brand and style names: style descriptions like "GTA-style illustration" usually work, but some models may reject or weaken prompts that name protected brands or real people. Describing the visual characteristics ("bold comic outlines, saturated colors, cel shading") gives more reliable results.
  • Large files: if your repository grows quickly, consider Git LFS for *.png and *.jpg. The default download limit is 25 MB per file (AGENT_FILE_TRANSFER_DOWNLOAD_MAX_FILE_SIZE).

Troubleshooting

"Validation script is not executable: validate.sh"

The bot checks the file mode stored in Git on its own branch, not the file on your disk. Typical causes:

Cause What happened Fix
Not committed git update-index --chmod=+x only changes the index; without a commit, the push contains nothing new. Commit and push.
Reset by a later git add On Linux/macOS, Git compares modes with the working tree. If the file on disk is -rw-r--r--, the next git add or git commit -a (e.g. after editing the script) stages 100644 again. chmod +x validate.sh, then add, commit, push.
Bot works on an old branch The bot runs the script from its branch. If that branch was created before the fix, it still has the old mode. Close the bot's PR, delete its branch and assign the issue to the bot again β€” or merge main into the bot's branch.

Check every stage:

git ls-files -s validate.sh                        # index
git ls-tree HEAD validate.sh                       # your last commit
git fetch && git ls-tree origin/main validate.sh   # the server

All three must show 100755.

"Validation script must be the committed version"

The script in the bot's workspace differs from the committed one. The bot is not allowed to modify validate.sh; change it yourself, commit it and let the bot start from the updated branch.

download-file or upload-file is refused or shown as "Disabled until … is configured"

The tool's allowlist is empty, or the request doesn't match it. The error message names the property. Check in particular:

  • Host: *.fal.media matches v3.fal.media, but not fal.media itself β€” list both.
  • Path: with images/**, a download to assets/… is refused. The allowlist and the folder convention in the system prompt must match.
  • Content type: with a content-type allowlist, a file whose bytes are not one of the listed types is refused β€” even if its name ends in .png.
  • Upload: upload-file needs both AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_HOSTS and AGENT_FILE_TRANSFER_UPLOAD_ALLOWED_PATHS.

The pull request was opened without all images

The bot ran validate.sh before all downloads were done: once a validation round passes and the workspace has changes, ai-git-bot finishes the run. Check that the system prompt contains "Step 2 – Store, document and validate (in ONE round)" from above, and consider making validate.sh stricter (e.g. require as many images as the README describes).

Downloads fail with HTTP 403/404

The fal.ai image URLs are temporary. If the downloads happen long after the images were generated, the URLs may have expired. Let the bot generate the images again.

Extend validate.sh

Further ideas for the quality gate:

  • Dimensions: require 16:9 or a minimum resolution, e.g. with a short python3 check of the PNG header.
  • Count: require exactly as many images as sections in the README.
  • No stray files: reject files outside images/ that a bot run shouldn't touch.

Remember that the bot only runs the committed version of the script, so changes take effect once they are merged into the branch the bot works on.

Summary

flowchart LR
    I[πŸ“ Issue<br/>request] --> B[πŸ€– ai-git-bot<br/>+ fal.ai MCP] --> D[⬇️ download-file<br/>+ Asset-Source] --> P[πŸ” Pull request<br/>review] --> M[βœ… Merge<br/>approved asset]

With a handful of configuration steps, ai-git-bot becomes a tool for more than code: an auditable image pipeline, in which every image can be traced back to its request, its prompt, its source and its approval.

πŸ“° Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.