AWS Builder Center
Weekend Creative Agent Challenge: MythForge

Weekend Creative Agent Challenge: MythForge

A daily fable that pairs a myth with a software engineering concept — written by AWS Nova models, stored in S3, served over CloudFront.

Data Engineering

Vision and What It Does

Myth-Tech Story Weaver is a creative agent project that turns mythology and technical concepts into short, memorable stories for software engineers. The main idea is to make abstract engineering topics easier to understand by presenting them as narrative parables. Instead of reading a dry explanation of a concept like deadlock, race conditions, caching issues, or retries, the user gets a story that connects that concept to a mythological event, character, or punishment. This makes the information more engaging and easier to remember.
The project solves a real problem: technical knowledge is often hard to retain when it is presented only as documentation or definitions. Storytelling helps because it creates an emotional and symbolic connection. For example, the punishment of Sisyphus can represent endless loops or repetitive work, while Pandora’s box can represent one action that releases many unexpected consequences. By combining these ideas, the system produces stories that are both educational and entertaining.
The workflow is simple but effective. A curated JSON library contains myth summaries and technical trivia. A Lambda function randomly selects one myth and one technical concept, builds a prompt, and sends it to Amazon Bedrock. The model returns a story, which is then saved in Amazon S3 as a Markdown file. A manifest file is updated so generated stories can be tracked over time. The result is a lightweight AI content pipeline that can generate reusable documentation-style artifacts.

How I Built It

I built the project as a serverless application with a small number of focused components. The content source is  content_library.json , which stores myths and technical trivia separately from the code. This made the system easier to maintain and expand because new content can be added without changing the generation logic.
The main application logic is in  lambda.py . The Lambda handler picks a random myth and a random technical concept, then constructs a prompt that asks the model to write a whimsical 100–300 word parable. The prompt also instructs the model to end with a short “Moral for Engineers” section. This structure was a deliberate choice because it keeps the output consistent while still allowing creative variation.
Amazon Bedrock Runtime is used to generate the story. I chose Bedrock because it fits well with an AWS-native agent workflow and keeps the implementation simple. The model does not need to be hosted separately, and the function can focus on orchestration rather than inference infrastructure.
Once the story is generated, it is written to Amazon S3 as a Markdown file. I chose Markdown because it is easy to read, easy to preview, and easy to reuse in a web app, documentation site, or blog. The filename includes the date and the selected content IDs so each artifact is traceable and unique. I also added a  manifest.json  file in S3 that records metadata for every generated story, which gives the project a lightweight history of outputs.

AWS Services Used and Architecture Overview

This project uses a compact AWS cloud architecture:
  • AWS Lambda: runs the story generation workflow.
  • Amazon Bedrock Runtime: generates the story text from the prompt.
  • Amazon S3: stores generated Markdown files and the manifest.
  • AWS CloudWatch: captures logs and helps monitor Lambda execution.
  • AWS CloudFront: can be used to serve the frontend and deliver content quickly through a CDN.
  • AWS IAM: controls access to AWS resources.
  • Amazon EventBridge Scheduler: can trigger the Lambda on a schedule.

Architecture Flow

  1. A Lambda invocation starts the workflow.
  1. The function selects one myth and one technical concept from the local content library.
  1. A prompt is built and sent to Amazon Bedrock.
  1. Bedrock returns a generated parable.
  1. The story is saved to Amazon S3 as a Markdown artifact.
  1. The manifest is updated with metadata about the new file.
  1. AWS CloudWatch captures logs, errors, and operational details for debugging and monitoring.
  1. AWS CloudFront can distribute the frontend or published story content efficiently to users with low latency.

Key Decisions

Why CloudWatch, CloudFront and EventBridge Scheduler Matter

CloudWatch was important because it gave visibility into the Lambda execution flow. It helped with debugging prompt issues, checking generated outputs, and confirming whether S3 writes and manifest updates succeeded. When working with serverless functions and external AI calls, logs are essential for understanding failures and performance.
CloudFront is useful for delivering the frontend or published content through a global CDN. Since the project includes a frontend folder with an  index.html  file, CloudFront helps make the app faster and more production-ready by caching and distributing static assets efficiently. It also improves the user experience when the generated stories are displayed in a browser.
EventBridge Scheduler was useful for displaying daily fables at 7AM UTC or 8AM West African Time. The application needed a way for new fables to be generated daily and that was solved by using EventBridge Scheduler as a triggerer.

Challenges I Faced

One of the biggest challenges was prompt tuning. The model needed enough structure to produce a coherent story, but not so much structure that the output became stiff. I had to refine the wording several times to get the right balance between creativity, length, and usefulness.
Another challenge was content quality. The generated story depends heavily on the source myth and technical trivia. If the source data is vague or too broad, the result can drift away from the intended metaphor. That made curation of the JSON library an important part of the project.
A third challenge was error handling and reliability. AI APIs can fail, throttle, or return unexpected results. I needed fallback behavior so the workflow would still be resilient when the primary model was unavailable. This was especially important because the project is intended to run as an automated agent.
A fourth challenge was observability. Without logs, it would be difficult to know whether the Lambda function succeeded, where it failed, or how long each step took. Adding CloudWatch logging helped solve that problem and made debugging much easier.
A fifth challenge was frontend delivery. Since the project includes a frontend structure, serving it reliably and efficiently required thinking about static hosting and CDN delivery. CloudFront helped address that by providing a fast, scalable way to serve the app.
A sixth challenge was my choice of models. I initially chose amazon.nova-2-lite-v1:0 but wasn't informed about the need for regional access so I switched to amazon.nova-lite-v1:0 as my main model and amazon.nova-micro-v1:0 as the fallback model
A seventh challenge was my own learning curve. I was new to AWS Lambda, CloudFront, CloudWatch, and Bedrock, so I struggled with understanding how the services fit together at first. Lambda was new to me because I had to learn how serverless execution works, how permissions are handled, and how to structure code for an event-driven function. CloudFront was also unfamiliar because I had to understand how it serves static content through a CDN and how it connects to the frontend. CloudWatch took some getting used to because I needed to learn how to read logs, debug failures, and trace execution. Bedrock was another new service, and I had to figure out how to structure prompts, call the runtime correctly, and handle model output. That learning curve slowed me down at first, but it also helped me understand AWS more deeply and made the final project more rewarding.

What I Learned

I learned that creative AI systems work best when strong data organization, prompt design, and operational tooling come together. I also learned that serverless architecture is a strong fit for lightweight creative workflows because it keeps the system simple while still producing persistent output.
Another lesson was that cloud monitoring matters even for small projects. CloudWatch made it easier to understand what the system was doing and to diagnose issues quickly. CloudFront also showed how a simple frontend can be made more polished and scalable with minimal additional complexity.
Deploying applications using AWS Lambda, EventBridge Scheduler, BedRock, CloudWatch, CloudFront were all new terrains for me and this challenge helped me step out of my comfort zone
Most importantly, I learned that an effective creative agent should generate something tangible, not just a temporary response. Saving stories as Markdown files and tracking them in a manifest makes the project practical, reusable, and extensible.

Link to the App or Repo

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article