launchly

Building Launchly: My Messy, Iterative Journey Creating an AI GTM Co-Founder with MeDo

#BuiltWithMeDo

I still remember the exact moment I got fed up.

It was 2:17 a.m. during my last startup attempt. I had just pushed a solid v1 of the product after six straight weeks of coding. The backend was clean, the frontend responsive, and authentication was solid. Then I opened a blank Google Doc titled "GTM Strategy" and… stared at it. For forty minutes.

I knew the product inside out. I could explain the architecture in my sleep. But translating that into customer profiles, launch sequencing, messaging frameworks, pitch narratives, and campaign cadences? That part always felt like trying to speak a language I'd only read about in books.

I've been shipping software professionally for a year. I've done the startup grind, joined hackathons, and worked on everything from internal tools to consumer apps. The pattern is always the same: the technical side eventually clicks, but the go-to-market side remains this opaque, time-sucking black hole that usually gets half-baked or outsourced too early.

So when I came across the Build with MeDo hackathon, something clicked. Their pitch was simple: describe what you want in plain English, iterate through conversation, and end up with a deployed full-stack application. No boilerplate. No framework decisions. No wrestling with deployment.

I was skeptical. I've seen plenty of "AI will build your app" tools come and go. Most generate toy demos that fall apart the moment you want anything non-trivial. But the hackathon had real prizes, and more importantly, it felt like the right excuse to finally build the tool I wished I'd had on that 2 a.m. night.

I signed up, used an invite link for bonus credits, joined their Discord, and decided to go all-in on a personal pain project.

The Idea That Actually Mattered to Me

I didn't want another generic AI wrapper. I wanted a true "GTM Co-Founder"—one single place where all the moving pieces actually talked to each other.

The app I envisioned, which I ended up calling Launchly, features several interconnected modules:

ICP Builder: Doesn't just spit out bullet points; it actually helps refine personas with supporting questions and counter-examples.
GTM Strategy Workspace: Generates phased launch plans tightly bound to your specific ICP.
Pitch Deck Generator: Creates logical slide structures with built-in suggested speaker notes.
Campaign Generator: Outputs realistic, multi-channel marketing sequences (LinkedIn, email, content, paid) with timing recommendations.
Brand Identity Section: Offers naming options, core messaging, and basic visual direction.
Launch Readiness Score: An intelligent metric that dynamically scales based on how much of the other foundational work you’ve completed.
Launchly AI: A persistent, overarching AI agent tying the ecosystem together that references everything you've built so far to give tailored, contextual advice.

The vision wasn't to replace a real marketing team. It was to give solo technical founders a force multiplier—something that could get 70% of the way there quickly, so the human could focus on the final 30% that actually requires taste and human judgment.

The Actual Build Process (It Wasn't Magic)

I opened MeDo and started with what I thought was a decent first prompt. It was long—probably too long—and crammed in way too many requirements at once. The first generation was… okay. The UI appeared and the navigation worked, but the individual tools felt shallow, like they were just calling an LLM once and dumping the raw response. The readiness score was static, and the main chat agent had zero memory of what was happening in other tabs.

That's when the real work began. This is where MeDo's iterative nature actually shone.

I spent the next several hours in a genuine back-and-forth with a very capable collaborator. I would describe a problem:

"The ICP output is too generic and doesn't reference the specific product context the user entered earlier."

MeDo would update the underlying logic, and then I'd test it. Sometimes the change was perfect on the first try. Other times I'd have to refine it:

"That's closer, but make the output more concise and add a section for 'objections we might face'."

Key Breakthroughs During Iteration:

Interconnectedness: I wanted the GTM Strategy tool to automatically pull insights from the ICP Builder. I must have iterated on that five or six times. At one point I literally typed: "When the user has already completed an ICP, reference the key pain points and demographic data in the strategy recommendations without being repetitive." The difference in output quality after that prompt was night and day.
The Launch Readiness Score: This started as a simple, dumb progress bar. I pushed MeDo to make it truly intelligent—weighting different modules differently, explaining why the score was at 43%, and providing concrete next actions to improve it.
The Contextual Chat Agent: Early versions would hallucinate details about work you hadn't actually done yet. I kept having to instruct it: "Only reference features and outputs that the user has actually generated in this session." Eventually, it clicked. There's something deeply satisfying about asking, "Based on the ICP I built earlier, what should I change about this campaign idea?" and getting a response that proves it actually remembered the persona details.

I also spent time on UI polish that I normally wouldn't have bothered with in a short hackathon sprint. While the generated UI was surprisingly clean, I kept tweaking the information hierarchy, adding subtle progress indicators, and designing helpful empty states.

One thing that surprised me was how well the visual editor complemented the chat interface. When a layout felt slightly off, I could just click into visual mode, drag elements around, and then jump right back to the conversational thread for behavioral changes.

By the time I wrapped up, I'd estimate I spent roughly five to six focused hours across two sessions. Not a full weekend. Not even a full day. Just a few intense blocks of describing problems and watching the app evolve.

What Actually Blew My Mind

As someone who has wired up frontends to backends the traditional way many times, the level of architectural coherence MeDo achieved was legitimately impressive. It generated a functional full-stack application out of the box containing:

A responsive, modern frontend with a consistent design language.
Backend logic that successfully handled data persistence between different modules.
Non-trivial state management so the readiness score and AI agent could accurately assess user progress.
Smart defaults and neat output formatting across five different AI-heavy tools.

The fact that all of this came from natural language conversation rather than me writing custom schemas, routing API endpoints, or building React components manually still feels a bit unreal.

It wasn't perfect, of course. There were moments where I had to be extremely precise with my prompts, and a couple of times I had to roll back changes that went in the wrong direction. But the speed of those corrections was so fast that the friction was minimal.

Using Launchly on My Own Projects

Once it was deployed, I immediately started feeding it one of my actual side projects. The experience was better than I expected.

The ICP builder forced me to be specific in ways I normally gloss over. The strategy generator surfaced sequencing ideas I hadn't considered, and the chat agent caught a flat-out contradiction between my brand positioning and a campaign idea I was considering. Watching the readiness score climb from 35% to 82% after completing the major modules gave me an odd but very real sense of satisfaction.

For someone like me—technical, opinionated, and usually overwhelmed by the non-technical hurdles of launching—it feels like having a very smart, slightly junior co-founder who never sleeps and is obsessively organized.

What I'm Taking Away

This project reinforced a few things I've been realizing about the future of software development:

The leverage is real: Five to six hours from a vague idea to a deployed, interconnected application with seven major features is just not something I could have achieved traditionally. The baseline expectation for speed has completely reset.
Conversation forces clarity: When you can't hide behind the excuse of "I'll fix that layout in the code later," you are forced to describe exactly what you want. That exercise ended up improving the quality of my actual thinking regarding the GTM problem itself.
Context and memory are everything: The most valuable parts of Launchly aren't the individual generators; they are the pipelines where information flows seamlessly between tools.

Tools like this don't replace developers—they completely change what developers spend their time on. Instead of wiring mundane CRUD operations, I spent my day thinking about product coherence, system prompt quality for internal agents, and user experience. That feels like an incredible trade.

Final Thoughts

Launchly isn't a polished commercial product yet; it's a hackathon project built by one tired developer having very long, hyper-focused conversations with an AI. But it works, it solves a real problem I've faced for years, and it was built in a fraction of the time I anticipated.

If you're a technical founder who has also stared at that blank "GTM Strategy" document at 2 a.m., I'd love for you to play with the prototype version here: 🔗 Launchly Live Prototype

And if you're considering joining the Build with MeDo hackathon before the May 20, 2026 deadline, I can tell you this much: the platform absolutely delivers on its core promise. The rest is entirely up to how specific, persistent, and creative you're willing to be in those conversations.

I'm genuinely curious to see what other builders create with this approach. The bar for a "Minimum Viable Product" just moved, and I'm still processing what that means.