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
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
- Why Git for images?
- How it works
- Prerequisites
- Step 1 β Prepare the repository
- Step 2 β Create the image-generation workflow
- Step 3 β Create a dedicated tool set
- Step 4 β Add the fal.ai MCP configuration
- Step 5 β Create the bot
- Step 6 β Request images with an issue
- Step 7 β Review and merge the pull request
- Bonus β Using a reference image (e.g. your face)
- 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-fileandfile-info(see the project'sdoc/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 -lis 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"]
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.
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-fileandwrite-filechange 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 andvalidate.shinto 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 asfile-info, but notdownload-file,write-fileorexecute. 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 withtools.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.shaccordingly.
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 committedvalidate.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 useswrite-filefor theREADME.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-fileorupload-fileis shown as "Disabled until β¦ is configured", the matching allowlist from the prerequisites is missing.βΉοΈ Results of validation tools are posted as comments. Every
validate.shrun therefore leaves a short comment on the issue.
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
headersfield with theKeyprefix. fal.ai expectsAuthorization: Key <key_id>:<key_secret>β aBearertoken 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
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-generationfrom Step 3 -
MCP configuration:
fal-aifrom Step 4 - AI integration: your existing one
- Git integration: your existing Gitea integration
- Repository: the image repository from Step 1
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.
π‘ 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.
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:
- 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.
- Enable
upload-filein the tool set (Step 3) andupload_filein the MCP tool selection (Step 4). - Commit the reference image, e.g.
references/my-portrait.jpg. - 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-filenever 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_pricingand 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
*.pngand*.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.mediamatchesv3.fal.media, but notfal.mediaitself β list both. -
Path: with
images/**, a download toassets/β¦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-fileneeds bothAGENT_FILE_TRANSFER_UPLOAD_ALLOWED_HOSTSandAGENT_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
python3check 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.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.











