Ideas I can't stop thinking about.

I keep coming back to a guy in a Vancouver apartment.

In 2003, Markus Frind built Plenty of Fish. For years, it was basically a one-man company. No giant development team. No venture capital machine. The site was free, ran largely on automation, and made its money from ads.

By 2008, POF was reportedly generating more than $10 million a year in profit.

In 2015, Match Group bought it for $575 million.

I don't bring that up because I want to build another Plenty of Fish.

I bring it up because one person once looked at the dating industry, ignored how everyone else was doing it, and changed it.

I think this industry needs that again.

Dating apps solved a real problem. They gave us access.

Twenty years ago, your dating pool might have been your school, church, job, friends, neighborhood, or the bar down the street.

Now it can be everyone.

That sounds like progress.

I'm not sure it was all progress.

We took something that used to happen largely through shared environments and turned it into a catalog of strangers.

Photo. Profile. Height. Job. Bio. Swipe.

Then, after we've already decided whether someone might be a romantic partner, we start a conversation and try to discover whether there's actually a connection underneath all that information.

I think we may have it backwards.

Dating apps show you the person and ask you to find the connection. What if we started with the connection and let you discover the person?

That's the idea I've been researching.

Not another swipe mechanic.

And not Facebook for single people.

The starting point wouldn't be browsing people at all.

It would be doing something together.

A conversation. A game. A shared interest. A challenge. A small group. Some reason for two people to interact that isn't immediately, Do I want to date this person?

You interact first.

You discover whether you enjoy each other.

Then you can choose to take the next step and learn more about the person behind that interaction.

Maybe nothing happens.

Maybe you make a friend.

Maybe you find people you actually belong with.

And sometimes maybe you find something more.

Obviously we can't recreate the social world of 1985. Nor should we try.

But we can ask what disappeared when dating moved from communities and repeated encounters to databases containing millions of strangers.

Familiarity. Context. Shared experiences. Mutual interests. The chance to observe someone without immediately evaluating them as a potential partner.

Maybe technology can restore some of that instead of removing even more of it.

The platform I'm imagining would provide the infrastructure, but not dictate every way people connect. People and communities could create their own activities, games, conversations and ways of meeting.

That's where I think this gets interesting.

AI could help someone discover where they fit, facilitate activities, moderate spaces, translate languages and make connections possible that geography once prevented.

But AI shouldn't tell you whom to love.

That's asking software to solve the wrong problem again.

I'm not pretending I know the complete answer. I don't.

There are enormous questions around safety, moderation, identity, gender balance, network effects, community quality, monetization, anonymity and whether this works at all once real humans get inside it.

That's partly why I'm posting this.

I'd especially like criticism from people who've worked in dating, social products, psychology, HCI, games, trust and safety, recommendation systems or network-effect businesses.

Tell me what breaks.

Tell me what's already been tried.

Tell me what I'm missing.

And if you think there's something here, I'd also like to talk to people interested in researching, challenging, designing or eventually building it.

I'm less interested in starting another dating company than I am in testing whether we've spent twenty years optimizing the wrong starting point.

Markus Frind didn't prove that one person can solve dating.

He proved something more useful.

The way we're doing it isn't the only way it can be done.

A few years ago, if I had an idea for a piece of software, the expensive part was obvious.

Building it.

You needed developers. Designers. Infrastructure. Time. Money.

I know that world pretty well. I've spent a lot of money over the years having software built.

Then AI coding arrived.

And suddenly something strange happened.

The part that used to be the hardest started becoming the easy part.

Today I can describe an application to Claude, Cursor, Gemini or another coding agent and watch it produce in hours what once might have taken a developer days or weeks.

That is extraordinary.

But the more I build this way, the more I keep running into the same problem.

The AI can build incredibly fast. But I still have to know what to tell it to build.

What database should this use?

How should the data be structured?

What authentication makes sense?

Which APIs should I use?

Which model should handle the AI features?

What should the user flow look like?

What happens when something fails?

What needs to be secured?

What should happen on mobile?

What should I build myself and what should I use an existing service for?

What am I forgetting?

AI has made writing software dramatically easier.

It has not eliminated decisions.

In some ways, it has made those decisions more important.

Because an AI coding agent is perfectly capable of making them for you.

That doesn't mean it will make the decisions you would have made.

It will often choose something reasonable. Sometimes something excellent. Sometimes whatever gets it to a working result fastest.

Those aren't necessarily the same thing.

And that has made me wonder whether we are solving the wrong part of AI-assisted development.

We keep building better ways to generate code.

Maybe what we also need are better ways to decide what code should be generated in the first place.

That's the idea behind something I've been working on.

I think of it as a BuildPrint.

Not source code.

Not a template.

Not a course teaching you how to program.

And not another AI that takes a sentence and immediately starts building.

It's the layer before that.

A sufficiently detailed plan for a piece of software that another person—or increasingly another AI—can actually build from.

The goal is to move as many important decisions as possible out of the middle of the build and make them before the build starts.

Architecture.

Features.

User flow.

Technology choices.

Integrations.

Design direction.

Security.

Deployment.

The little decisions that don't seem important until you're three days into a build changing something that breaks five other things.

I want to see how close we can get to this:

Think once. Plan deeply. Build fast.

That doesn't mean one-shot software development magically works every time.

It doesn't.

I'm testing that now.

My process is to take actual software ideas, research them, create a detailed initial build plan, hand that plan to an AI coding agent, build the application, find everything the plan got wrong or missed, fix it, and then work backward from the finished application.

That last part is important.

Because a theoretical build plan and a plan extracted from something that has actually survived the build are two different things.

I want the second one.

And once you start thinking about software this way, another possibility appears.

Most software isn't completely unique.

A CRM might need authentication, contacts, search, permissions, dashboards and notifications.

A project-management application might need authentication, search, permissions, dashboards and notifications too.

The businesses are different.

A lot of the underlying decisions aren't.

So why are we asking AI to rediscover all of those decisions every single time we build something?

That seems incredibly wasteful.

We spent decades creating reusable code.

Maybe the AI era needs reusable decisions too.

That is the part of this idea I find most interesting.

Imagine finding something someone has already successfully built and not merely downloading their code.

Instead, you can understand the decisions behind it.

How it works.

How it is structured.

What it depends on.

What choices were made.

And enough information to reproduce the important parts using whatever coding tool you prefer.

Then imagine being able to take pieces of different proven approaches and use them to plan your own build.

Not copying an application.

Learning from how applications are actually built.

There is another problem I think this could help solve.

AI-generated software is starting to look like AI-generated software.

The same layouts.

The same dashboards.

The same cards.

The same gradients.

The same choices.

That's understandable.

If you tell an AI, “Build me a modern CRM,” it has to fill in an enormous number of blanks.

So it does.

I'd rather expose some of those blanks.

Show me the sensible default.

Show me alternatives.

Tell me why one is better for what I'm building.

Then let me decide.

I don't want to recreate Figma.

I don't want to recreate GitHub.

And I definitely don't want to create another giant development platform where you need a course just to understand the development platform.

The idea is almost the opposite.

Make the complicated decisions easier to understand, make good defaults obvious, and then get out of the way so you can build.

There's also a group of people I think AI coding is about to bring into software who weren't traditional developers at all.

Small-business owners.

Designers.

Creators.

Entrepreneurs.

People who understand a problem extremely well but couldn't justify spending $50,000 to find out whether their solution worked.

AI changes that equation.

But giving someone Claude Code doesn't automatically give them twenty years of software-development judgment.

That gap is what interests me.

Maybe the valuable layer between an idea and an AI coding agent isn't another coding agent.

Maybe it's accumulated knowledge from thousands of builds about what works, what doesn't, what people choose, and why.

I don't know yet.

There are plenty of ways this idea could fail.

AI coding models may become good enough that detailed build plans become unnecessary.

Developers may prefer starting from code.

Non-developers may find even a simplified planning system too technical.

Plans may become obsolete too quickly as frameworks, models and APIs change.

And there is a difficult question underneath the whole thing:

How detailed does a BuildPrint have to become before it genuinely saves more time than it takes to create?

That may be the question that decides whether this works.

So I'm building them.

Not hypothetical examples.

Actual applications.

I'm going to create the plan, build from it, document where it fails, improve the process, and see whether the next person—or the next AI—can reproduce the result substantially faster.

If that works, then I think there may be something much larger here than a collection of software plans.

There could be a shared knowledge layer between having an idea and having working software.

And as AI makes the distance between those two things shorter, I suspect that layer becomes more important, not less.

Because when almost everyone can build,

knowing what is worth building—and knowing how it should be built—becomes the advantage.

In 1994, a real estate agent paid dues to their local board, split a commission with their broker, and went to work.

That was the whole system.

No lead generation subscriptions. No CRM licenses. No platform fees. No e-signature software. No Zillow Premier. No digital marketing budget. You knew your market, you knew your clients, and you did the work.

Today that same agent pays for all of it.

MLS fees. NAR dues. Zillow Premier Agent subscriptions. Realtor.com lead costs. Follow Up Boss or kvCORE for the CRM. DocuSign for the signatures. Photography. Signage. Social media advertising. Premium listing placement on platforms built entirely from data the agents themselves created.

$30,301 a year on average. Just to be allowed to do the job.

Top producers in major metros pay closer to $100,000.

I've spent time inside this industry. I built a directory that put 10,000 agents on page one alongside Zillow and Trulia — for $100 a year. I watched how the platforms grew. I watched the fees follow. I watched agents absorb cost after cost because the alternative was invisibility.

The agents didn't get richer as the platforms scaled. The platforms did.

Zillow now generates $8 billion a year. From listings agents created. Photos agents paid for. Neighborhoods agents spent careers learning. Relationships agents spent years building. And when a buyer clicks on one of those listings and becomes a lead, Zillow sells that lead back to the agent who generated it — at 40 percent of their commission.

That's not a marketplace. That's a toll booth on a road you built yourself.

The NAR settlement changed the commission conversation forever. Buyer's agent compensation is now negotiable in writing before every showing. The platforms know what that means. They're moving fast to insert themselves as the value layer between buyers and sellers. If they succeed, the agent becomes a commodity. A transaction processor. A notary with a license.

Two million agents are watching this happen in real time.

I'm not writing this because I want to build another real estate portal.

I've seen enough portals.

I'm writing this because one thing has been true for thirty years and nobody has fundamentally changed it.

The agents power the system. The platforms own it.

That's the problem I've been researching. Not a new search interface. Not a shinier lead generation product. Not a prettier version of what Zillow already built.

The question I keep returning to is more fundamental than any of that.

What would real estate infrastructure look like if the people who built it actually owned it? What would the tools look like if they were designed for agents instead of extracted from them? What happens when the movement that's already building inside every agent forum, every Reddit thread, every broker meeting finally has somewhere to land?

I don't have every answer yet. This industry is complicated and the problems run deep.

But I've watched two million people pay $30,000 a year to platforms that treat them as a resource to be harvested.

That feels like a problem worth solving out loud.