Sprout
Note: at the time of authoring, this post is lacking some detail/rigor. But I want need to get this post out and I’ll update later! I left out pictures and screenshots and play-by-play for the most part, focusing only on the essentials.
Project Overview
“When in doubt, build with heart.” That’s been my mantra for a while, but this project gave those words an entirely new depth. For the third entry in the Prometheus Project, I wanted to create something deeply personal: a tool to make reading fun for my son, Riley (almost 6yo). He’s at that stage where reading practice feels more like a chore than an adventure, and I knew I had to find a way to change that.
Enter Sprout, an AI-powered app designed to dynamically generate children’s stories based on word lists and topics. It started as a simple idea but quickly became an ambitious challenge of creativity, technology, and sheer persistence.
Also, the sharp among you may have noticed that this project is code name “Sprout” not “Scout” as originally advertised — well. Plans change. And that’s a story for another day.
The resulting tool is linked in the website above! Note: due to high DALL-E costs and some server processing issues, this tool is not enabled for "live" use at the moment. Please reach out if you're interested in using such a service, and check out the demo to see what a "real" result looks like! The words should be tappable to pronounce them.
Problem Statement
I’m a parent who knows what it’s like to struggle to make learning enjoyable. Riley loves screen time and gets excited about anything interactive, especially when he can make choices. But sitting down with a book? That’s harder to sell. The question I asked myself was: How do I bring the excitement of screens and games into reading while keeping it educational?
I envisioned a tool that could generate stories using the exact words Riley is learning in school, blending them into fun, interactive narratives. Not just any stories, but ones that could include his name, reflect his interests, and feel uniquely his. At its heart, Sprout needed to make reading more than practice—it had to make it personal and fun.
Objective
Sprout’s goals were deceptively simple but required complex execution:
1. Dynamic Storytelling: Use AI to generate children’s stories tailored to a child’s specific word list and a topic of their choice.
2. Interactive Engagement: Allow for children to “tap to listen” on the words so that they can learn words they don’t already know.
3. User-Focused Design: Create a polished, intuitive interface that parents and kids could easily use together.
Build Process
Like all Prometheus projects, Sprout began as a journey of exploration. What set this one apart, though, was how personal it was. This wasn’t just about proving a concept or hitting a technical milestone—it was about building something my son could enjoy, which meant the stakes felt higher at every step.
It's a project with a lot more going on than I realized which I expect is going to be a bit of a theme with these projects. It has a frontend, it has a rear backend, it has API services connected and there’s still some server side (off?)loading that needs to be built.
Getting Started
The app relied on Next.js for the framework, OpenAI’s GPT-4 API for story generation, Amazon’s Polly for text to speech, and Vercel for deployment. I had used none of them before (except GPT), and weaving them together to create something seamless wasn’t as straightforward as I’d hoped. There were a number of videos I watched to learn about how so-called “prompt engineers” or “composers” or … call them what they are, content creators & influencers: I’ll elaborate more on these later but there is a treasure trove of wisdom in these videos as well as a whole lot of gaps which I’d like to fill:
… and more… but these were the ones I kept coming back to.
The first video in that list was the most helpful and I kept returning to that guide for structure and thoughts. It may have also sent me astray for a number of issues I would have down the road.
Frontend / UI: v0.dev
v0.dev is a powerful AI-driven platform designed to simplify and accelerate the process of building user interfaces and connecting them to backend functionality. It allows developers to visually design their UI elements, then generates the underlying code and file structure needed to bring those designs to life.
An interesting experience I had with v0.dev was realizing I had completely misunderstood its purpose at first. I went into it thinking it was simply a code creation tool—a stepping stone to get things started. It seemed straightforward enough for building a site or app, so I dove in. What I didn’t grasp initially was the real genius behind it: v0.dev is designed to help you nail down all your UI elements correctly from the start and then seamlessly layer your backend functionality on top. That connection between frontend and backend turned out to be more challenging than I expected, and I learned the hard way by restarting my site several times. But the payoff was worth it.
Once I got the hang of it, this tool blew me away. You can literally just tell it what you need—“do this,” “adjust that”—and it will build your user interface for you, whether it’s for a website, an app, or something entirely custom. It’s like having an extra pair of hands (and a pretty brilliant brain) to help bring your vision to life. All that being said, I still have not found a way around the shadcn-UI formatting nightmare that squirreled me away in my codebase for literal hours trying to untangle why I kept getting errors. More on that later…
Backend and code generation
Cursor AI is an advanced code-focused assistant that goes beyond simply explaining how to implement features or debug issues—it actively participates in the development process. Unlike traditional coding tools, Cursor AI analyzes your codebase, generates actionable solutions, and even executes tasks directly.
The video I watched demonstrated a workflow where v0.dev was used to create UI elements, which were then carried over to Claude for building out file structures and backend components and then finally imported into cursor AI. While this method generally worked and showed promise, I ran into my own set of challenges—specifically trying to align the file structure I envisioned with the UI elements generated by v0.dev. It’s an area where I’ll need to refine my approach, but the underlying process was solid.
However, the real magic—the true linchpin of the entire project—was Cursor AI. As one video described it, and I honestly probably agree agree, “the most incredible software I have ever used.” Cursor AI is a game-changer. It doesn’t just explain how to do something; it does it for you. You sit down, ask it to analyze your codebase or execute a specific task, and it doesn’t just hand you a to-do list—it delivers results. The first time I used it, I experienced a genuine eureka moment unlike anything since the first time I used Shazam (yes, the music ID app). It’s hard to describe exactly what that feels like, but the sheer efficiency and brilliance of this tool left me floored. It’s a whole new way to think about (no-)coding and development.
Backend and code generation
With the front end and back end in place, it was time to add some actual meat to the bones. I had a clear vision of what I wanted: dynamic story generation tailored to my son’s reading level, buttons and text that could speak when tapped, and engaging visuals to bring the stories to life. There was a lot to tackle, but here’s a summary of what I ended up building. OpenAI’s GPT-4 and DALL-E are handling the heavy lifting for story and image generation, though figuring out the right prompts took quite a bit of trial and error.
For text-to-speech functionality, I integrated Amazon Polly, which has been surprisingly smooth—I’m not even sure if I’m being charged for it yet. I also tested alternative services for image generation since DALL-E turned out to be pricier than expected, but for now, it’s what’s in the system. The setup itself was fairly straightforward: grab an API key, plug it in, debug a few errors, and sort out content guidelines for what could or couldn’t be displayed. It took some back-and-forth, but seeing it all come together made the effort worthwhile.
Workflow TL;DR
The following summarizes what and how I put things together in a very brief format it's probably redundant with the toolbox section but again… I'll clean this up later!
v0.dev: Designed and generated the app’s UI elements for a polished front end
Cursor AI: Analyzed code, automated debugging, and implemented backend tasks efficiently
OpenAI GPT-4/DALL-E: Generated dynamic stories and accompanying images
Amazon Polly: Added text-to-speech functionality for interactive story narration
Squarespace: Created a mobile-friendly blog to document and showcase the project
Vercel: Hosted and deployed the app with backend integrations
Getting out of the "endless unhelpful GPT” loop
I ended up in this endless unhelpful loop more times than I can count and needed to make some rules for myself around when I needed to just move on or change my approach. I have some more thoughts on how to approach this that I'll write about later but suffice to say it was really important to figure out in this project and will be really important going forward too.
Results & Lessons Learned
Project Status: Live
The website is live … albeit it doesn’t fully work for all users. DALL-E is expensive and I haven’t fully enabled the generation workflow. I’ll upload a video of it working soon and figure out at least some ways for people to get their hands on it soon!
Use Cases
The Sprout project serves as a dynamic and engaging tool for personalized reading practice, combining AI-generated stories with interactive features to make learning fun and effective. It allows parents to create custom stories tailored to their child’s reading level and interests, complete with audio pronunciation and choose-your-own-adventure elements to keep kids engaged. The app’s user-friendly design also enables parents to upload word lists, track progress, and customize story parameters, making it both practical and impactful. Beyond personal use, Sprout demonstrates the potential of integrating AI, text-to-speech, and visual storytelling for broader educational applications in classrooms or tutoring settings.
Lessons Learned
It’s Okay to Start Over: I restarted parts of this project more times than I can count. Each iteration taught me something new, whether it was a better way to structure my code or a design tweak that improved the user experience.
Perfectionism is a Double-Edged Sword: I spent more time than I probably should have trying to make everything “just right.” While this led to a better product, it also meant some late nights staring at error messages.
Ask for Help: AI tools like Cursor and Claude were lifesavers, but only when I knew how to guide them. Sometimes, stepping away and asking for a fresh perspective—even from a machine—was the key to moving forward.
Costs
Honestly I think I’m forgetting some things but here’s the high level summary for now:
OpenAI GPT-4 API Credits: $20
Cursor AI: $20/month (sort of comes with Claude at least)
Claude from Anthropic: ended up using this a lot, I agree that it generally seems better with code than GPT. More thoughts on Claude later!
The Toolbox
Section coming soon! See the main build details for tools used.
#efficiencies
New section coming soon! I’d like to write about how projects stack on each other to make future projects faster and easier. For this one, the blog post was much faster since I invested in the website framework last week, for example!
Next Steps
Sprout is live and evolving! While Riley is enjoying his stories, I’m planning to make this available for other parents. Upcoming features include:
• Interactive word pronunciation assistance.
• A parent portal for tracking word lists and story usage.
• Image-free modes for minimalistic storytelling.
… and more! Let me know your thoughts on this project and I’ll build from there.
