Building LaunchPointAI: From an AI Experiment to a Content Production Platform
It Started With a Simple Idea
When someone asks what I did this summer, the easy answer would be, “I built an AI platform.” But that doesn’t really describe it.
What started as an idea for using artificial intelligence to find interesting topics and create content gradually turned into something much larger. Over the course of the summer, I designed, coded, tested, broke, repaired, redesigned, and expanded what eventually became LaunchPointAI.
I have spent more than 30 years working with computers, networks, servers, security, and just about every other part of information technology. AI was different. I had used AI tools, but I wanted to see what would happen if I stopped treating AI as something I simply talked to and started treating it as part of an actual software system.
The original idea was straightforward: Could I build a system that continuously researches what is happening, identifies promising subjects, creates content around them, and helps publish that content?
That idea became a project originally called TechTime. At first, the application was relatively simple. I built a Python backend using FastAPI, SQLAlchemy, and SQLite, with a React frontend using Vite and Material UI. Then I started adding things. Before long, TechTime wasn’t a little experiment anymore. It needed a new identity. Eventually, TechTime evolved into LaunchPointAI.
Building the Research Engine
One of the first challenges was figuring out what the AI should write about. Generating an article with AI isn’t particularly difficult. The more interesting problem is deciding which article is worth creating in the first place.
So I started building a research system. LaunchPointAI could collect information from multiple sources and place that information into a research queue. From there, the system could analyze trends and begin identifying subjects that might represent good content opportunities.
That eventually evolved into an Opportunity Engine. Instead of simply saying, “This topic is popular,” LaunchPointAI began evaluating signals such as trend strength, momentum, freshness, audience match, competition, monetization potential, shareability, lifespan, and video potential.
The system could then help classify an opportunity as Create, Watch, or Skip. That was an important change in how I thought about the project. LaunchPointAI wasn’t supposed to be an AI that blindly generated content. It was supposed to help make decisions.
Teaching the System to Think Ahead
Once the Opportunity Engine was working, another question appeared: a subject might be popular right now, but will anyone care about it tomorrow? That led to the Forecast Engine.
The forecast system attempts to determine where an opportunity is headed instead of looking only at where it is today. I deliberately kept forecasting advisory. A forecast can influence a recommendation, but publishing remains under human control. I wanted automation, but I didn’t want to remove judgment.
From Opportunities to Missions
Eventually, finding good opportunities wasn’t enough. The system needed to do something with them. That led to the idea of missions.
When LaunchPointAI identifies an opportunity worth pursuing, it can become an actual production project. Behind the scenes, I added safeguards such as duplicate protection and mission history so the system knows what it has already acted upon.
The workflow had evolved into something much more sophisticated: Information Sources → Research → Trends → Intelligence → Opportunities → Forecasting → Approval → Mission → Production → Review → Publishing.
Building the AI Workforce
Once a mission becomes a project, LaunchPointAI needs to create the actual content. I built an AI production pipeline capable of generating multiple assets from the same project.
Depending on the project, that can include titles, outlines, keywords, articles, YouTube scripts, social media posts, monetization ideas, and featured images. The important part is that these aren’t supposed to be unrelated AI responses. They are pieces of the same project.
Eventually, I added a Generate Everything workflow that could run the project’s AI production pipeline rather than requiring every asset to be generated individually. LaunchPointAI was becoming a production system instead of a collection of AI buttons.
Then I Decided It Should Make Videos
This may have been the point where I made my summer considerably more complicated. I wanted LaunchPointAI to create YouTube videos—not just scripts, but actual playable videos.
That turned into the Video Studio. The workflow became: YouTube Script → Storyboard → AI Scene Images → Narration → Video Render → Review → Publish.
Each step created a new set of problems. The script needed to stay faithful to the source material. The storyboard needed to divide the script into logical scenes. Images had to correspond to those scenes. Narration had to match the script. The images and narration then had to be assembled into a playable video.
I also wanted to be able to edit the pieces before the final render. Even browser behavior became part of the development process. It was one of many reminders that software development is often less about the big idea and more about solving hundreds of little problems between the idea and something that actually works.
Creating Content From Real Source Material
Another important part of LaunchPointAI became Custom Studio. I didn’t always want AI deciding what the source material meant. For instructional How-To articles in particular, accuracy mattered more than creativity.
Custom Studio allowed approved source material to become authoritative. The system could use that information to generate downstream content while keeping the procedure tied to the original source.
There were times when the title was correct but the generated script wasn’t actually following the source document. Fixing those relationships forced me to improve how LaunchPointAI tracks source authority throughout the production pipeline. When it finally worked, it represented another important step toward making the system useful for real-world content rather than AI demonstrations.
Connecting LaunchPointAI to the Real World
Eventually, content sitting inside LaunchPointAI wasn’t enough. It needed somewhere to go. So I began building publishing integrations.
One of the biggest was WordPress. LaunchPointAI can now connect to my production website, create posts, assign categories, create excerpts, upload featured images, and send content to WordPress as a draft or published article.
The featured-image workflow became its own project. Initially, LaunchPointAI created a placeholder describing what an image should look like. I eventually connected the production pipeline to real AI image generation. The image can be generated, stored with the project, uploaded to WordPress, and assigned as the article’s featured image.
The first time an entire article traveled from the LaunchPointAI production workflow to my actual website—with its content, category, and AI-generated featured image—it felt very different from watching another test endpoint return “success.” The system was doing real work.
Building the Website Around It
LaunchPointAI also led to another unexpected summer project: rebuilding my website. If the system was going to create content, I wanted a proper place to publish it.
I redesigned kerryashbrook.com, improved the homepage and category pages, added article cards and featured images, updated the About page, and worked through the inevitable collection of CSS and layout problems.
By then, the original experiment had crossed an important line. LaunchPointAI wasn’t just running on my development server anymore. It had become part of an actual publishing workflow.
There Were Plenty of Things That Didn’t Work
A story about building software wouldn’t be complete without mentioning how often it broke.
I dealt with API errors, database problems, authentication issues, incorrect routes, failed fetches, stale review states, source-mapping problems, browser compatibility, WordPress synchronization problems, image-generation issues, HTTPS configuration, proxy configuration, and plenty of screens that simply didn’t do what I expected.
Every time LaunchPointAI became more capable, it exposed another architectural problem that hadn’t mattered when the application was smaller. Solving those problems was probably where most of the actual learning happened.
AI Helped Me Build AI
There is also something unusual about how LaunchPointAI was created: I used AI extensively throughout the development process.
AI helped me think through architecture, troubleshoot errors, examine logs, write and modify Python and React code, design workflows, diagnose database problems, and consider what the next version of a feature should look like. That created an interesting feedback loop. I was using AI to help build software designed to use AI.
But AI didn’t simply build LaunchPointAI for me. There were countless decisions about what the system should do, how it should behave, what should remain under human control, which suggestions made sense, and which ideas needed to be rejected or changed.
My decades of IT experience turned out to matter enormously. The technologies were new. The process of troubleshooting wasn’t.
Where LaunchPointAI Is Today
What began as TechTime is now a platform with research collection, trend intelligence, opportunity analysis, forecasting, mission management, AI content production, Custom Studio, image generation, a video-production workflow, publishing integrations, and feedback mechanisms that can make future decisions better.
The workflow now looks something like this: Find information. Understand it. Identify opportunities. Forecast them. Decide what is worth pursuing. Start a mission. Create the content. Review it. Publish it. Measure the results. Learn from them.
There is still plenty I want to build. In fact, that’s probably one of the biggest lessons from this summer. Software like this is never really finished. Every feature creates another possibility. Every solution reveals another problem. And every time I think, “LaunchPointAI can do this now,” it isn’t very long before I start wondering, “What if it could also do this?”
So, How Did I Spend My Summer?
I could have spent more time at the beach. Instead, I spent a surprising amount of it staring at PowerShell windows, Python tracebacks, React components, database records, WordPress pages, API responses, AI-generated images, and video renders.
I watched a small experiment turn into one of the most ambitious software projects I’ve ever built.
I also proved something to myself. After more than 30 years in IT, there are still completely new things to learn.
AI didn’t make my previous experience obsolete. In many ways, it made that experience more valuable. Understanding systems, troubleshooting, asking the right questions, recognizing when something doesn’t make sense, and refusing to accept “almost working” are exactly the skills that helped turn an idea into LaunchPointAI.
So when someone asks me what I did this summer, I think I’ve finally settled on my answer: I learned how to build with AI. And in the process, I built LaunchPointAI.