Weekend Creative Agent Challenge: Building a Weather-Themed Daily Art Agent on AWS
Most creative tools require me to show up — open the app, type a prompt, wait, download. I wanted to try the opposite: an agent that works while I'm not looking, and has something new ready when I check in. The idea I landed on was simple enough to actually finish: generate one piece of AI art every morning, themed to that day's real weather.
The problem it solves isn't really about art generation itself — plenty of tools already do that. It's about removing the "open the app and prompt it" step entirely. The best version of a creative tool, I think, is one that runs on its own schedule, makes its own decisions about what to create, and just has the output waiting for you. This project is a small proof of that idea: a fully serverless pipeline that checks the weather, decides on a mood and style, generates an image, and publishes it to a gallery — once a day, with zero manual triggering.
How it works, at a glance
Every morning, an automated trigger wakes up a function that:
- Fetches the current weather for a fixed location (Lahore, in my case) from a free weather API
- Translates that weather — temperature, wind, conditions — into descriptive art language (a "misty, cool, reflective" prompt for drizzle; "scorching, intense saturated heat" for a hot day)
- Combines that with the season and a deterministic daily pick of art style and subject, so each day's piece has its own character without needing a human to choose
- Sends the resulting prompt to an image-generation model
- Saves the finished image and updates a small gallery index, so a static webpage always shows the latest piece plus a history of everything generated so far
By the time I open my laptop, there's a new image waiting — no prompting, no clicking generate.
How I built it
I started with the architecture before writing any code, because for a "set it and forget it" agent, the shape of the system matters more than any individual line: everything needed to be serverless, so there'd be no server to maintain or forget about, and everything needed to fit comfortably inside AWS's Free Tier.
The build itself was a single Python Lambda function containing the whole pipeline — weather fetch, prompt construction, model call, S3 write — kept deliberately in one file rather than split into multiple functions, since the daily workload is tiny and splitting it up would have added coordination complexity for no real benefit. Alongside it, a lightweight static HTML page reads a JSON index file from S3 and renders the latest image plus a scrollable gallery of past days.
The trickiest part wasn't the code — it was the deployment plumbing, which is where most of the actual learning happened. A few decisions and course-corrections along the way:
● Weather-to-prompt mapping. I built a lookup table from standard weather codes to mood language, plus separate temperature and wind descriptors, so the final prompt blends multiple weather signals rather than just "it's raining." This is the part I expect to keep refining over time — some combinations still produce noticeably better images than others.
● Deterministic daily variety. Rather than pure randomness for style and subject choice, I seeded the random generator with the date itself. That way the same day always produces the same choice if the function ever gets re-run, which made debugging much less confusing.
● Cross-region routing. My AWS account's default region didn't have the image model I needed available at all — a genuine gap in regional model availability, not a configuration mistake. Rather than migrate the entire stack, I pointed just the model API calls at a different region while keeping storage and compute where they were. It's a good example of how serverless components don't all have to live in the same place to work together.
● Fresh-account quota limits. New AWS accounts start with very conservative, sometimes zero, request quotas on certain models — something I didn't anticipate until I hit a wall of throttling errors. Diagnosing that took actually reading the Service Quotas console line by line rather than assuming it was a code bug, and ultimately required filing a support case to get the limit raised.
AWS services used
● AWS Lambda — runs the entire pipeline: weather fetch, prompt building, model invocation, S3 writes. Free Tier covers this completely at a once-daily cadence.
● Amazon Bedrock (Nova Canvas) — the text-to-image model that turns the weather-derived prompt into the actual artwork.
● Amazon S3 — stores every generated image, hosts the JSON gallery index, and serves the static gallery page itself via S3 static website hosting.
● Amazon EventBridge — the scheduler. A daily cron rule invokes the Lambda function each morning with no human involvement.
● IAM — scopes the Lambda execution role's permissions to talk to S3 and Bedrock.
The architecture is intentionally simple: a scheduled trigger, a single compute function, one storage layer doing double duty as both a data store and a web host. No database, no queues, no orchestration layer — the smallest set of pieces that could do the job.
What I learned
The biggest lesson wasn't technical in the way I expected. I went in assuming the hard part would be prompt engineering or image quality. Instead, most of the real work was in account-level plumbing: regional model availability, IAM permissions, and fresh-account service quotas that don't show up until you actually hit them. None of that is visible in a finished demo, but it's most of what "deploying an agent" actually means in practice — the code is often the easy part.
I also came away with a better instinct for reading error messages literally rather than pattern-matching to the nearest thing I'd seen before. A KeyError on an environment variable and a ThrottlingException on a service quota look similar in a stack trace at a glance, but they point to completely different layers of the system — one's an application bug, the other's an account-level constraint that no amount of code changes will fix. Learning to tell those apart quickly, and knowing which AWS console page actually answers the question, was probably the most transferable skill from this whole project.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article