Last week I built something I'd been putting off for a while.

An AI GTM (Go-to-Market) Planner.

The idea was straightforward. A founder describes their startup in a few lines, and instead of spending days across tabs and spreadsheets, they get a structured GTM strategy right there.

I wasn't chasing a billion-dollar idea. I was trying to answer one honest question:

How much can one person actually build today by combining product thinking with AI?

Why I Built This

Working around startups long enough, you start noticing patterns.

Every founder is asking the same questions:

• Who exactly is my customer?

• Which competitors should I be studying?

• How do I position this thing?

• Which channels make sense to launch on?

• What does my first month even look like?

The answers usually exist somewhere. They're just scattered across random docs, ChatGPT threads, notion pages, and half-finished spreadsheets.

I wanted to pull all of that into one clean experience. Instead of asking AI ten separate questions, the user asks one. The system handles the rest.

What It Actually Generates

• Market research

• Competitor analysis

• Ideal Customer Profile (ICP)

• Positioning and messaging

• Four-week launch roadmap

• Content ideas

• GTM score

• Exportable report

The goal was never to replace strategic thinking. It was to cut out the repetitive research so founders could spend more time actually making decisions.

How I Approached Building It

This project genuinely changed how I think about development.

I didn't start with code.

I started with the product. Mapped every output I wanted. Broke the app into independent modules. Only after the structure was clear did I start implementing with AI help.

And even then, I didn't ask AI to "build an app." I gave it focused tasks:

• Design one screen

• Create one component

• Fix one bug

• Write one prompt

That produced far better results than trying to generate everything at once.

The Architecture

Pretty straightforward flow:

User Input → AI Prompt Engine → Structured JSON → Frontend Components → Local Storage → Export

Each section is independent, which makes it easy to improve one module without touching the rest.

The Biggest Lesson

The hardest part wasn't the code.

It was figuring out what the AI should actually produce.

Writing good prompts felt a lot like designing APIs. If the structure is vague, the output is all over the place. Once I defined clear sections, formats, and expectations, the quality jumped immediately.

Prompt design is becoming a product skill. Not just an "AI thing."

AI Doesn't Remove Engineering

Before this, I half-expected AI to just spit out production-ready software.

It doesn't work like that.

AI speeds up implementation. It doesn't make product decisions for you.

I still had to think through:

• Information architecture

• User flows

• Error handling

• UI choices

• Feature prioritization

• Output quality

Those calls are still on you.

What I'd Improve Next

This is V1. The backlog already has:

• Multi-model support

• Live market research

• AI-powered competitor discovery

• Editable GTM canvas

• Team collaboration

• CRM integrations

• Export to Notion and Google Docs

• AI memory across sessions

Eventually I want it to feel less like a report generator and more like an actual GTM co-pilot.

What This Changed For Me

Before this project, I thought software development was mostly about writing code.

Now I think it's increasingly about designing systems.

The better you define the problem, the better AI can help you solve it. That doesn't make developers less important. It makes product thinking more important.

Final Thoughts

This wasn't about launching a startup.

It was about learning a different way to build.

We're entering a phase where one person can ship things that used to need a small team. The edge won't go to whoever writes the most code. It'll go to whoever understands problems deeply, designs clean systems, and knows how to work with AI effectively.

Still building. Still learning.

Normally, this would mean opening a blank file, staring at it, writing some HTML, getting frustrated, watching three YouTube tutorials, getting more frustrated, and eventually thinking about paying someone to do it.

Instead, I opened Lovable, described what I wanted, and had a working structure in about 20 minutes.

That felt weird honestly. Good weird.

What I actually used and why

Lovable

For generating the initial structure and components.

You describe what you want in plain English and it builds it.

The first version wasn't perfect, but it was 70% there, which is far more than I would have had after 20 minutes starting from scratch.

That 70% starting point changes everything psychologically.

You're no longer staring at a blank screen.

You're editing and improving.

Cursor

This is where things got genuinely interesting.

Lovable gives you working code, but you don't always understand what it generated.

Cursor lets you go inside the code, ask questions about what specific parts are doing, and make targeted edits without breaking everything around it.

I started understanding the structure of what was being built rather than just accepting the output blindly.

Claude and ChatGPT

For refining copy, improving information architecture and thinking through UX decisions.

Questions like:

• Does this navigation flow make sense?

• Is this headline clear enough?

• Does this section add value?

Having a thinking partner speeds up the parts that are more judgment than code.

GitHub

For version control.

The first time I broke a working page and had nowhere to go back to, I understood why this matters.

Now I commit after every meaningful change.

What surprised me

I expected AI to write code.

That part wasn't surprising.

What surprised me was how much reducing friction changed my relationship with building.

Usually, the gap between:

"I have an idea"

and

"This thing exists"

is huge.

Most ideas die somewhere in that gap.

Killed by setup time, learning curves or simply the exhaustion of starting from zero.

These tools shrink that gap significantly.

Not to zero.

You still debug things.

You still hit walls.

You still wonder why something looks perfect on desktop and completely broken on mobile.

But the ratio between building and struggling shifts noticeably.

The bigger shift honestly is who gets to build.

This isn't only about speed for developers.

It's about people who understand products, systems and design being able to bring ideas to life without depending entirely on someone else.

That changes what's possible for builders, operators and founders.

You still need:

• Clear thinking

• Taste

• Problem solving

• Patience

AI doesn't replace any of that.

It just removes the part where you spend four hours debugging a CSS issue before you've even started on the actual idea.

What I'm building

Right now, I'm focused on building my personal website and getting the fundamentals right.

Beyond that, I'm building Cite & Core, an initiative around GEO, SEO and brand visibility.

The problem I'm interested in solving is helping brands understand where they actually show up:

• Search engines

• AI answers

• Communities

• Social platforms

and identifying what's missing.

It's still early, but I'm excited to explore where it goes.

I'm also spending time learning more about AI agents and workflows and sharing what I learn along the way.

The honest version of what I think is happening

We're moving from:

Learn to code first, then build.

towards:

Learn to build, and deepen the technical side as the problem demands.

That's not a downgrade.

If anything, it feels closer to how great builders have always operated.

They start with the problem.

Then they go as deep technically as necessary.

For anyone sitting on an idea because the technical barrier felt too high, that barrier is meaningfully lower today than it was even a couple of years ago.

If you're building something with Lovable, Cursor or Claude, I'd genuinely love to see what you're working on.