
Weekend Showcase Challenge: MoodMuse — Type a Feeling, Get a Poem and a Mood Board
Most AI tools ask you to be precise. Describe the output you want, specify the style, iterate on the prompt until it behaves. MoodMuse asks for the opposite: give it something vague.
Most AI tools ask you to be precise. Describe the output you want, specify the style, iterate on the prompt until it behaves. MoodMuse asks for the opposite: give it something vague. And as of this weekend, it doesn't wait to be asked at all.
Vision & What It Does
You type a short mood or scene, rainy Sunday morning, wet wood after rain, midnight city lights, and MoodMuse hands back two things at once: an original short poem, and a ju mood board image generated to match it. Side by side, on one screen. No account, no saved history, no second click to get to the good part.
The problem it solves is small and human. Creative block is rarely a shortage of tools; it's a shortage of a starting point. Writers, designers and anyone staring at an empty page usually don't need another blank canvas. They need something to react to. MoodMuse exists to hand you that something in about eight seconds, from four words you typed without thinking too hard.

That was the app I shipped for the Creative App weekend. This weekend I added the part I couldn't stop thinking about: MoodMuse now dreams on its own.
Once a night, unprompted, it reads every mood it has already generated, decides on one it has never tried, writes the poem and paints the image itself, and adds the result to a public Dream Journal on the site. Nobody types anything. Last night it woke at 3am and invented fresh popcorn aroma. I was asleep.
So there are two ways to use it now. You can give it a feeling and watch it answer. Or you can scroll the journal and read what it came up with while nobody was looking.
How I Built It
Weekend one: build it local, then fight the account.
A
MOCK_MODE environment variable in the Lambda handler, defaulting to true , let the entire app (frontend, API shape, loading states, error states) get built and clicked through with zero AWS dependency. A local server using only the standard library replicated the exact API Gateway HTTP API (v2) request and response shape, so going live was designed to be a one line change.That part worked. The image model did not.
The original design called for Amazon Nova Canvas, and it never returned a single successful invocation once deployed. Nova Canvas is marked Legacy account wide, and a brand new account with no prior invocation history gets a hard
AccessDenied that surfaces through the SDK as a confusing ResourceNotFoundException . Titan Image Generator, the obvious fallback, has been fully retired. A full unfiltered dump of the account's Bedrock catalogue confirmed something I didn't expect: there was no active pure text to image model available to me at all. Every active Stability AI model was an image editing tool (upscale, inpaint, sketch control) and each one required an input image I didn't have.The fix was to stop looking for the model I wanted and use the one I had. I pointed the app at
stable-image-control-sketch , fed it a neutral 512×512 grey seed image, and dropped control_strength to 0.15 so the text prompt dominates over a deliberately uninformative input. It's a text to image generator assembled out of an image editing tool, and it works.Four more bugs stood between that and a working deploy, each found by reading the actual error rather than guessing. Third party Bedrock models route through AWS Marketplace and need
aws-marketplace:ViewSubscriptions and Subscribe on the Lambda role. Cross region inference profiles route where they like, not where you named them, so an IAM ARN scoped to one region fails silently. A missing OPTIONS route makes the CORS preflight 404 before Lambda is ever invoked, so CloudWatch shows nothing at all while curl works perfectly. And plain S3 static hosting is HTTP only, which Chrome silently upgrades to HTTPS and then hangs on. That last one moved the frontend to AWS Amplify Hosting.Weekend two: teach it to dream.
The showcase brief invited combining two earlier weekends into one build, so I took the creative app I'd shipped and gave it the thing an agent has that an app doesn't: the ability to act without me.
I was careful about what "agent" means here, because a cron job that calls an API is not an agent. The dreaming layer has four properties, and I built it around them deliberately:
- Memory. It reads its own journal before deciding anything.
- Self direction. It asks Nova Micro to invent a mood it has never dreamt, given everything it has already dreamt. It is not picking from a list I wrote.
- Action. It writes to public state anyone can see.
- Guardrail. A novelty check that aborts before the $0.07 image call if it would repeat itself.
That third point matters more than it looks. My first design had the dreamer choosing from a curated list of evocative moods, which would have made "self direction" a fiction. It would have been shuffling a deck I stacked. Generating the mood from the history is what makes the memory real. Nine dreams in, every single one is model generated; the fallback list has never fired.


Three things went wrong, and all three are worth passing on.
EventBridge Scheduler needs its own IAM role. This is different from classic EventBridge Rules, which use a resource based policy on the Lambda. Scheduler assumes a role you create and hand it. Get this wrong and the schedule silently never fires: no error, no log, nothing. I verified with a single fire schedule two minutes out and watched it land before creating the recurring one.
My error handling would have destroyed the journal. The function that loads
entries.json from S3 originally caught every exception and returned an empty list. Reasonable looking code. But the next step writes the journal back, so one transient S3 read failure would have produced a single entry entries.json and wiped every previous dream. Unattended. At 3am. It rewrote it to distinguish a genuinely missing key (fine, first run, proceed) from any other error (abort the run, write nothing), and to copy the previous manifest to entries.prev.json before every overwrite. Failing open is the wrong default for anything that replaces a whole file.The agent was inventing to a template, and you can see it happen in the journal. My first prompt asked for moods "different in season, time of day and texture". The model dutifully rotated the first two and ignored the third: winter night in starlight, spring dawn garden, summer twilight beach, autumn dusk forest. Technically all distinct. Obviously formulaic. Asking more nicely wasn't going to fix it, so I rewrote the prompt to anchor on something small and physical, and explicitly banned the words morning, afternoon, evening, night, dawn, dusk, twilight and the four seasons. What came next: rain soaked cobblestones, the feel of snowmelt, campfire smoke breeze, old book smell, fresh popcorn aroma. Those first four entries are still in the journal. I left them there, because the change is more interesting than a clean gallery.
I built and debugged all of this using Kiro, AWS's agentic IDE, with a rule I'd recommend to anyone shipping against a live deadline: the app was already a published competition entry, so every stage started with a rollback artifact and ended with a smoke test against the live endpoint.
AWS Services Used / Architecture Overview
Services: Amazon Bedrock (Nova Micro for text, Stability AI Stable Image Control Sketch for imagery), AWS Lambda ×3, Amazon API Gateway (HTTP API), Amazon EventBridge Scheduler, Amazon S3, AWS Amplify Hosting, AWS IAM, Amazon CloudWatch.
ON DEMAND (weekend one) AUTONOMOUS (weekend two)═══════════════════════ ════════════════════════Browser EventBridge Scheduler │ Amplify Hosting, HTTPS │ cron(0 3 * * ? *) │ POST /generate │ Europe/London ▼ ▼API Gateway (HTTP API) Lambda · dreamer │ POST + OPTIONS /generate │ reads journal, invents ▼ │ an unseen mood, guardrailLambda · handler ▼ │ S3 · journal/ └──────────────┬───────────────────┘ entries.json + img/*.png ▼ │ SHARED GENERATION CORE │ Bedrock · nova-micro-v1:0 → poem │ Bedrock · stability control → image │ ▼ GET /journal → Lambda · journal → presigned URLs (1 hr) → galleryBoth paths call the same generation module: one codebase, two entry points. The read path for the gallery goes through API Gateway rather than a public bucket, with presigned URLs minted at request time so they never go stale, and the journal Lambda's role is read only by design. An internet facing function should be structurally incapable of writing the journal it serves.
On cost, precisely: Lambda, API Gateway, S3, EventBridge Scheduler and Amplify Hosting are genuinely $0 at this volume. Bedrock inference is not. Nova Micro costs a fraction of a cent per call, and the Stability model runs $0.07 per image. Nine autonomous dreams plus a weekend of testing has cost under a dollar; nightly, it's about $2 a month. I set a budget alert before the agent's first paid invocation, and the novelty guard exists partly so it can't spend money repeating itself. "$0 hosting, pennies in inference" is the honest version.
What I Learned
A model in the docs is not a model in your account. The most useful thing I learned all summer. Nova Canvas is documented, discoverable, and completely inaccessible from a fresh account, and the console's manual model access page has been retired, so there's no page left to tell you no. I now check
list-foundation-models against the actual account before designing around anything.Silent failures cost more than loud ones. The missing
OPTIONS route took more of my time than every noisy error combined, precisely because nothing anywhere reported a problem. The same is true of an unverified schedule. I now treat "no logs at all" as a stronger signal than an error message, and I don't trust a scheduled job until I've watched one fire.Fail closed on anything that replaces state. The journal wipe bug is the one I'll carry furthest. It looked like defensive error handling and was actually a data loss vector, and it would only ever have fired unattended, at night, with nobody watching. A skipped run costs nothing. A wiped journal costs everything.
Constraints produce better answers than plans. I had a design that depended on a model I couldn't have. The replacement, an editing model driven with a blank canvas, is stranger and more interesting than what I set out to build. The same thing happened with the prompt: banning half the vocabulary produced better moods than asking for better moods did.
Autonomy is a design property, not a scheduler. Adding a cron trigger takes ten minutes. What took the thought was making the thing on the other end have memory, make a decision I didn't make for it, and hold a guardrail. And being honest with myself when my first design quietly removed the decision.
Link to App or Repo
Type anything into the box to see the on demand path. Then scroll down to the Dream Journal, where every entry was invented, written and painted by the app itself, on a schedule, with nobody watching. Each one is timestamped with when it happened.
A builder who inspired me
Lewis Sawe, for The Museum That Grows, an agent that wakes once a day, reads everything already in its collection, and invents one new artifact that fits, with nobody in the loop. It reframed what I thought a weekend build could be: not a thing you demo, but a thing that keeps going after you close the laptop. MoodMuse dreams because that build made me want it to.
Built solo across two weekends. Founder of Columns & Pillars Ltd, Oxford. Agentic AI architecture and responsible AI governance for regulated environments.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article