How AI Turned Me From a Non-Technical Founder Into a Builder

For most of my career, I considered myself a non-technical founder.

My strengths have always been on the product, design, and business sides. I loved identifying opportunities, designing experiences, building partnerships, and figuring out how to bring products to market. I knew what I wanted to build, but I relied on engineering teams to transform those ideas into reality.

Over the past few years, that has changed. Not because I suddenly became a software engineer, but because AI fundamentally changed what it means to be a builder.

Like many people, my journey started with ChatGPT. At first, it was the obvious use cases: drafting emails, organizing thoughts, conducting research, planning the business, brainstorming product ideas, and writing marketing copy. Before long, it became less of a tool and more of a thought partner, helping me move faster and think more clearly. Today, it's difficult to imagine my workday without it.

The real shift, however, happened when I stopped asking AI to write about products and started asking it to help me build them.

That's when I started experimenting with AI-native development tools, beginning with Lovable.

For someone without a traditional engineering background, it was a breakthrough. Instead of trying to communicate ideas through static wireframes or lengthy product requirement documents, I could build working prototypes. I could visualize features, experiment with user experiences, and sit down with our engineering team to review something tangible rather than hypothetical. One of those prototypes eventually became a real mobile application that our team continued building together.

That was the moment I realized AI wasn't simply making me more productive. It was changing how I approached building products.

The next step was stepping outside the browser and into the development environment. I'll admit, it was intimidating at first. Claude Code, terminals, GitHub, local environments. It all felt like learning another language. So I did what I always do when I'm learning something new: I asked questions.

I followed tutorials. I broke things. I started over. I learned where files lived, how repositories worked, and how cloud environments connected together. Slowly, the mystery disappeared. Then one day, something clicked. The terminal stopped feeling like a developer tool. It simply became another conversation window.

The industry deserves a lot of credit for making that possible. Modern platforms have dramatically lowered the barrier to entry. Authenticating with GitHub is straightforward. Cloud providers make deployments accessible. Integrations that once required deep technical expertise are increasingly guided and intuitive.

The gap between technical and non-technical founders has never been smaller.

For decades, that distinction shaped how companies were built. Technical founders built products while non-technical founders translated ideas into requirements and waited for engineering to bring them to life. AI is beginning to blur that boundary. Increasingly, the scarce skill isn't writing code. It's recognizing the right problems, making good product decisions, and working effectively with AI to turn ideas into products.

Today, I lead the development of multiple internal products alongside our engineering team. Not because I'm writing every line of code, but because I can prototype, validate, iterate, and communicate ideas faster than ever before. I understand enough of the process to actively shape how products are built rather than simply handing ideas to an engineering team and waiting for updates.

That journey eventually led us to ask a much bigger question: if AI can make one founder dramatically more effective, what happens when an entire engineering department is designed around AI from day one? That question became the foundation of what we've built at Misfit Labs.

We realized that the same shift happening at the individual level could happen at the organizational level. If AI could make one founder dramatically more effective, perhaps the bigger opportunity wasn't building better coding assistants. It was redesigning the engineering organization itself around people and AI working together as one system.

As a result, over the past year, our team has been developing what we call our Agentic Engineering Department, an internal operating model where experienced product leaders, designers, engineers, and AI agents work together as one coordinated system.

Our team brings together more than 75 years of combined experience across product, software engineering, infrastructure, design, and delivery. AI doesn't replace that experience. It amplifies it. It includes former Apple engineers, repeat founders, product leaders, and operators who have built and scaled companies across healthcare, infrastructure, consumer software, and enterprise technology.

Every workflow we refine, every lesson we learn, and every product we ship strengthens the system we use to build the next one. Instead of starting from scratch each time, every project leaves the organization smarter than it was before.

Ironically, I spend very little time in the terminal today. Instead, I spend my time orchestrating.

Internally, we manage our engineering workflows through our own platform, CodeBake. Watching a traditional Kanban board move on its own still feels surreal. Specialized AI agents coordinate work, reference a shared project ledger as the source of truth, complete tasks, and hand work off between specialized roles, much like an experienced engineering organization would. It's not automation for the sake of automation. It's coordinated execution.

The shared context across our projects means that both our people and our AI agents are continuously learning. Decisions are preserved. Patterns are reused. Best practices become institutional knowledge rather than tribal knowledge.

The result is that we're able to run multiple product teams in parallel, developing more than five ventures simultaneously while making far more efficient use of AI than traditional one-person, one-chat workflows. Instead of isolated conversations with isolated context, we're orchestrating an entire engineering organization that shares knowledge, collaborates, and continuously improves together.

The irony doesn't stop there: the biggest lesson I've learned through this entire journey isn't really about AI. It's about restraint.

When you realize you can build almost anything, the temptation is to build everything. But that's no longer the hard part. AI has made creating software dramatically easier. The harder challenge is deciding what actually deserves to exist.

At Misfit Labs, every product starts with the same question: Will this solve a real problem for real people? If the answer is yes, we build it. If not, we move on. AI hasn't changed the importance of product judgment. If anything, it has made it more valuable. When building becomes easier, choosing what to build becomes the real competitive advantage.

Looking back, AI didn't make me an engineer. It made me a better founder.

More importantly, it changed how our entire company thinks about building software. We no longer see AI as another tool in the toolbox. We see it as a teammate that, when paired with experienced people, thoughtful processes, and a clear vision, unlocks an entirely different way of creating products.

That shift has changed how we think about engineering itself. For decades, software development was largely constrained by the availability of technical talent. Great ideas still required specialized teams to translate vision into working products, which naturally separated product thinking from execution. AI has begun collapsing that distance. The people with the clearest understanding of the customer, the strongest product instincts, and the best judgment can now participate directly in building, validating, and refining software in ways that simply weren't possible a few years ago.

I don't believe this means everyone suddenly becomes an engineer. The expertise required to design resilient systems, build scalable infrastructure, and develop production software remains incredibly valuable. But I do think it changes what effective collaboration looks like. Product managers, designers, founders, marketers, operators, and engineers can now contribute much closer to the work itself, reducing the friction between an idea and a working product.

That's ultimately what AI changed for me. It didn't teach me how to write software from scratch. It gave me enough fluency to participate directly in the creative process of building, to iterate on ideas at the speed they occur, and to have fundamentally different conversations with our engineering team. The relationship shifted from handing off requirements to solving problems together.

That experience also shaped how we've built Misfit Labs. We don't think of AI as something individual employees use to become incrementally more productive. We think about how an entire organization can operate differently when every function is designed around AI from the beginning. Individual tools matter, but they're only one piece of the equation. The real opportunity lies in designing workflows, systems, and organizations that allow people and AI to amplify one another over time.

The biggest shift wasn't that AI taught me to code. It was that it removed many of the barriers between having an idea and putting it in front of real users. For founders, that fundamentally changes the job. Building is becoming less about technical specialization and more about judgment, iteration, and knowing which problems are worth solving.

I suspect the founders who thrive over the next decade won't necessarily be the ones who write the best code or craft the best prompts. They'll be the ones who develop the clearest understanding of their customers, make the best product decisions, and build organizations where experienced people and AI compound each other's strengths. That's the future we're building toward at Misfit Labs, and I believe we're still only beginning to understand what's possible.