What's left when anyone can build?

Now this is a story all about how my life got flipped, turned upside down

Instead of moving to Bel-Air, I accidentally became someone who builds software. Here’s the story of how it happened.

The terrible no good very bad idea

I’ve spent the last eleven and a half years at Launch Academy, a nonprofit tech incubator in Vancouver, working with founders and builders. A few found terrific success. You can Google them. But the majority, you probably haven’t heard of. Here’s why.

They don’t always raise venture capital. In fact, the stats show that 97% of Canadian startups don’t raise capital. This doesn’t mean their businesses aren’t successful. Many make healthy profits and some employ other staff. But their work, their attendance at events, their pivots, their failures, their wins: none of it gets recorded unless they write about it themselves. And most of them don’t.

I wanted to build a place where builders could have a permanent, verified record of what they’ve actually done. Not a resume. Not a portfolio. A record. Something where the things on your profile are there because they happened, not because you wrote them.

I did what you’re supposed to do. What I’ve told hundreds of founders to do over the past decade. Go lean. Make a landing page. Go talk to people.

The feedback was lukewarm. Not because the idea was wrong, but because the pages were all marketing language. Nobody could tell what I was actually proposing. There was nothing to interact with. Many thought I was trying to rebuild Linkedin. A lot of ‘cool story, bro’.

I couldn’t justify hiring a developer for something that hadn’t been validated. That’s the advice I’d give anyone in my position. Don’t burn money before you have signal.

So it sat there. The idea that couldn’t get past the gate.

The dark room

Then our son was born.

Here’s the thing about newborns: they need to be held. A lot. In the dark. My wife and I took shifts, and during mine I’d be awake for hours with nothing to do but rock him to sleep with my phone in my free hand.

I had a lot of time alone with my thoughts. Eventually, it wandered back to my idea.

The project was dead by every conventional measure. No validation. No developer. No momentum. But I also had, for the first time in years, hours of uninterrupted quiet with nothing to do and nowhere to be.

At some point during one of those 3am sessions, I started tinkering. Not with any plan. I’d heard people talking about AI tools that could generate code, and I had nothing but time. So I opened a chat window and started describing what I wanted.

Phone, baby, browser tabs

The first thing I tried was just asking GPT to write code. It could give me full pages of HTML and JavaScript. I’d copy the output, paste it into an editor, and see what happened. It worked for a splash page. It did not work for anything more complex.

Then I found Lovable, a visual AI builder. You describe what you want, it renders it in real time, you can click around and iterate. This is where things actually started to take shape. Login screens. Profiles. A directory. Real features, not just a landing page.

But Lovable’s prompting frustrated me. I couldn’t get it to do what I wanted with its native prompts alone. So I started asking GPT to write the code, then copy-pasting that into Lovable’s editor. GPT writes it, I paste it in, Lovable renders it, something breaks, I go back to GPT, get a new version, paste that in. Each tool interpreted my instructions differently, so the results never quite matched.

I did this for about a month. From my phone, in the dark, rocking a baby.

The site was showing real promise. Working login. Profiles. Something that resembled a community directory. But the process was brutal. I was burning through monthly credits on font changes and background colors. Every small tweak required a round trip between two tools that didn’t talk to each other.

It was becoming clear that Lovable had limits I was going to hit. It deployed from its own internal copy of the code, not from my repository. It couldn’t store credentials securely. When something went wrong, it tried to fix the problem itself, often making things worse.

But it got me further than I’d ever gotten. There was an actual app. People could log in. For someone with zero code experience, building one-handed between midnight and 4am, that felt like something.

Six times in 28 minutes

One night, the site went down. Blank page.

The cause was simple. A small change had removed the credentials the app needs to talk to its database. A one-line fix. Put the password back, site comes up.

But Lovable tried to fix it on its own. Six times in 28 minutes. Each attempt more creative and convoluted than the last. At one point it was rewriting entire files to work around the missing credential instead of just putting it back. The AI was spiraling. It had no concept of “this is a one-line fix, stop.”

I went into the editor and pasted the key back manually. Thirty seconds to do what the tool couldn’t do in half an hour.

That was the moment. Not because Lovable is bad. It’s genuinely good for what it’s designed for. But I wasn’t building a prototype anymore. I had real users. I’d outgrown the tool.

And I didn’t realize it at the time, but this was the first lesson that would keep repeating: knowing when something isn’t working anymore is its own skill. The tool was fine. It was fine for months. The problem wasn’t that it broke. The problem was recognizing that I’d passed the point where it could take me further.

Two hours

I’d been hearing about Claude Code. The idea was that instead of copying between browser tabs, Claude could read the actual codebase, write files directly, run commands, push changes. No intermediary.

It took about two hours to set up. The difference was immediate.

I went from burning credits on font changes to shipping full features in a single session. Claude Code could see the whole project. When I asked for something, it knew what files existed, what patterns to follow, what would break. It wasn’t generating code in isolation and hoping it fit. It was working inside the real thing.

I burned through the $20 plan in about 40 hours. Had to upgrade to Max.

“Of course I need SEO”

A few weeks in, I asked a question that turned into two of the most consequential decisions in the entire project.

I needed to move off Lovable’s hosting. The outage proved it couldn’t handle production. So I asked Claude: Netlify or Vercel?

Claude said either works, but only go Vercel if you’re on Next.js. You’re on Vite, so Netlify is simpler.

I didn’t know what Vite was. I didn’t know I was on it. Lovable chose it for me months earlier.

I asked what the difference was.

Claude explained. My app was client-side rendered. The server sends a blank HTML page, JavaScript fills it in after. Search engines see the blank page. AI tools see the blank page. The actual content is invisible to anything that isn’t a browser.

Next.js serves the content directly. Google can read it. Shared links show previews instead of empty boxes.

I’m building a public directory of builders. Of course I need SEO.

Two moves in one night. Full framework migration. New hosting. Twenty-five thousand lines of code. Deployed and live.

I found out later that migration would typically be scoped as a multi-week project for a team. I genuinely didn’t know. I just described what I needed and followed the steps. That’s not a flex. It’s an observation about what happens when you don’t know something is supposed to be hard: you don’t scope it into a multi-sprint project. You just do the thing.

I’m not saying ignorance is a strategy. A senior engineer would have caught edge cases I missed, planned for rollbacks I didn’t think about, and probably done it more safely. But the conventional timelines for this kind of work are built around conventional constraints, and the constraints changed faster than the industry’s expectations.

What I already knew

Before I wrote any serious code, before the migration, before the real building started, I wrote three documents.

What I was building and why. Every term on the platform, defined precisely. And the technical architecture: how data moves, where logic runs, what connects to what.

I didn’t know how to build any of it yet. I just knew what I wanted. Ten years of working in this ecosystem meant I knew the problem, the people, the language, the gaps. Writing that down was the easy part. It was just what I already knew, on paper.

Those documents get loaded into every AI session. When the AI tries to build something that doesn’t fit, the docs catch it. Wrong term, wrong architecture, wrong tone: the documents are the guardrails.

For a while I thought this was the whole insight. Write better constraints and you get better output. That’s true, but it’s the surface-level version. The real insight is underneath.

The reason the documents worked isn’t that they were well-formatted or followed some template. They worked because I had genuine expertise in what I was building. I knew the ecosystem. I knew the people. I knew what existing tools got wrong and why. The ten years I spent not coding were the ten years I spent learning everything else. The documents were just the translation layer between that knowledge and the AI.

A developer could have written the code faster. But they wouldn’t have known what to build. Not because they’re not smart. Because they haven’t sat in a thousand meetings with founders who are invisible to the ecosystem. They haven’t run fourteen years of programs and seen which support structures actually help and which ones are theatre. They don’t have the relationships to seed a community platform with the right 150 people on day one.

The domain knowledge was the real asset. The AI just made it buildable.

April 1

April 1, 2026. Anthropic hosted an event in Vancouver called Claude for Everyone. Twelve presenters showing things they’d built with Claude. I was one of them.

I was nervous. Not about the demo. About standing in front of real engineers and showing something I’d built. People who would know if it was held together with tape.

I told the story. Baby, dark room, phone, copy-paste loop, Claude Code, the outage, the migration. Then I switched to a live screen share and walked through the platform. Directory. Profiles. Credentials on the record. Created a new account on stage.

Then I put a QR code on the screen.

“This gives you a profile and a credential that says you were in this room tonight. Scan it if you want.”

People scanned it. It worked.

Six months earlier, I showed people splash pages and got polite nods. Now people were signing up on the spot. Not because I became a better presenter. Because there was finally something real to react to.

The thing that had been blocking me for years, the inability to make the idea tangible without a developer, just wasn’t a blocker anymore. And with that removed, everything I’d spent the last decade learning could actually become something people could touch.

Three models, one operator

That was three months ago. The platform is live at buildrs.dev. A few hundred people use it. I’ve run a demo night series where other builders present what they’ve shipped. It’s modest by any startup metric. But the workflow around it has become something genuinely worth describing.

The workflow has evolved into something I would have found absurd a year ago.

Multiple parallel AI coding sessions run through Conductor, each in its own isolated workspace, each on its own branch, each with the constraint docs loaded. At peak, five sessions running simultaneously: schema, backend, frontend, admin, dashboard. I review every diff. A separate session handles merging.

A chat layer on top of that handles everything that isn’t code. Strategy. Product decisions. Database operations. Project management. Meeting prep. Email campaigns.

Then a review layer. I started using Codex and GPT-5.5 as code reviewers. They read what Claude Code wrote, flag issues, file tickets. Different models catch different things.

The system is: Claude Code writes, Codex and GPT-5.5 review, Claude chat orchestrates, and I make the decisions.

There are days where the workflow feels a little absurd when I step back and describe it. A year ago I was pasting code between browser tabs on my phone. Now I’m orchestrating multiple AI models across different roles, reviewing diffs, and deciding what ships.

I still don’t consider myself a developer. I probably never will. But the job I’m actually doing, the direction-setting, the review, the judgment calls, turns out to be the job that matters most regardless of who or what is writing the code.

The gate

I used to say “ideas are a commodity, execution is the key.” I still believe that. But the definition of execution has shifted under our feet.

Execution used to mean: can you build the thing? Can you ship the code? Do you have the technical team to turn the vision into a product? That was the gate. If you couldn’t get through it, your idea stayed an idea. I watched it happen to hundreds of founders over the years. Good ideas. Real market understanding. No way to build.

That gate is functionally gone now. Not lowered. Gone.

Thinking, not typing

Execution is something else. It’s velocity. It’s taste. It’s knowing when to push and when to quit. It’s understanding which problem is worth solving and for whom. It’s the judgment to look at what the AI built and say “that’s wrong” even when it looks right.

And it’s still hustling. Getting out there, talking to customers, selling. That part hasn’t changed and probably never will. But there are tools now to help fine-tune that process too, to move faster between the conversation and the iteration, to test an idea in the morning and ship the fix by afternoon.

I want to be clear about something: this doesn’t diminish developers or product managers or designers. Not even a little.

Their value was never that they know Python or Figma or how to write a Jira ticket. Their value is how they think. How they process information and turn data into something useful. How they take a hundred customer interviews and identify the one feature that changes everything. How they build something at scale that’s safe and secure and doesn’t fall over. How they look at a product and know, instinctively, what’s wrong with it.

That thinking is more valuable now, not less. Because the bottleneck used to be “can we build it” and now the bottleneck is “should we build it, and is this the right version of it, and who is it actually for.”

The tools made the building accessible. They did not make the thinking accessible.

Taste, judgment, domain expertise, relationships, timing: those still take years. They still take reps. They still take showing up.

What this proved (and didn’t)

buildrs isn’t proof that I’m a great builder. It’s proof that the barrier moved.

I didn’t learn to code. I just finally didn’t have to. And what was left, once that barrier came down, turned out to be the stuff that was always going to matter most. The years you spent learning your industry. The relationships you built. The instinct for what’s worth doing and what isn’t.

If anyone can build, everyone will

But here’s the part that makes all of this complicated: if anyone can build, everyone will.

The flood is already here. The haters will call it AI slop, and honestly, a lot of it is. The app stores and product directories are filling up with things that took a weekend to build and will take less than that to be forgotten. When the cost of building drops to near zero, the volume of what gets built explodes, and most of it won’t matter.

Product-market fit is harder to find today than it was a year ago. Not because the problems got harder. Because the noise got louder. There are more apps, more tools, more “I built this in a weekend” posts, more things competing for the same attention from the same people.

And every startup now has a built-in competitor it didn’t have before: what if your customer just builds it themselves? If the tools that let me build buildrs on my phone are available to everyone, then the person you’re building for might just build their own version. Not better. Not more polished. But good enough, and tailored exactly to their needs.

For some, that’s terrifying.

But for the crazy ones? The misfits? The rebels? The troublemakers? They might just change the world.

This post was written by me. Stitched together with ai.