Why PathPilot?
The hiring landscape is brutally competitive. AI has made it easier to apply to jobs, but harder to stand out. Generic content blends into the noise. Companies filter aggressively. Candidates feel lost, burned out, and unseen.
PathPilot exists to fix that.
Not by automating the human out of the process, but by amplifying the human in it.
From Custom GPT Experiments to a Full Product
When I look back at the earliest days of PathPilot, it still amazes me how something that began as a late night experiment with custom GPTs turned into a full career platform with real users, real impact, and real complexity under the hood. I did not set out to build a full product. I just wanted to understand how far personalization could go, how deeply an AI system could mirror the tone, voice, and intent of an individual user.
Those experiments quickly became the seeds of something bigger.
Discovering the Power of Personalization
My early GPTs, like Merlin, were scrappy, improvised, and honestly a little chaotic. But they revealed something important. When an AI has the right context about a person, its output stops feeling generic and starts feeling genuinely helpful. It feels like support instead of automation, clarity instead of noise.
People kept telling me the same thing: “I wish Chat GPT always worked this way.” That stuck with me. It became the core insight behind PathPilot: the technology should adapt to the person, not the other way around.
Building the Personality Vault
To make personalization real, I needed to capture the elements of identity that shape how someone communicates. Tone. Voice. Strengths. Stories. Principles.
This became the Personality Vault – a structured way for people to teach the system who they are. Not through one questionnaire or a few sliders, but through evidence: writing samples, stories, brand statements, personality profiles, and lived experiences.
Once users started filling this in, something clicked. Their career materials, their outreach, even their interview prep began sounding like them. Not like an LLM approximation, but like their actual selves.
Turning Experiments into Software
But building a product is very different from building a clever prototype. Suddenly I needed authentication, navigation, workspaces, onboarding flows, security layers, and database schema that could support dozens of assistants. I had to design and redesign the UI. I had to write PRDs and break everything into batches. I had to think about performance, Supabase integration, error handling, and how to deliver a consistent experience.
And I had to do it all inside Lovable, a platform I was learning in real time.
Some days everything worked beautifully. Other days I was debugging initialization sequences for my assistants or figuring out why something wasn’t saving to Supabase. But that is the creative process. It moves forward, not in a line, but in loops.
The Breakthrough: A System, Not a Tool
The real turning point was realizing PathPilot wasn’t just a “career assistant” tool. It was a system. A place where all the elements of a job seeker’s experience could live together. Their story. Their materials. Their strategy. Their progress.
Workspaces brought order to the chaos. Assistants became modular specialists instead of generalists. The Personality Vault became the single source of truth. Suddenly, everything connected.
How I Built PathPilot
PathPilot was built as a continuous design conversation.
Much of the real work happened through free-form, spoken dialogue, using voice mode to think out loud, challenge assumptions, and clarify intent in real time. I would start with a loose idea or problem, talk it through until the shape of it became clear, and then have that thinking distilled into a mini PRD. We wrote many of these. Each one captured a moment of clarity, a hypothesis about what mattered next, and an explicit set of tradeoffs. Those PRDs were not documentation for its own sake; they were thinking tools, used to slow the work down just enough to preserve coherence.
Vibe-Coding and Dog-Fooding
From there, the PRDs were translated into something buildable. I would break them into tightly scoped batches, organized by feature, function, UI, and data, so they could be executed cleanly in Lovable. Sometimes this was accompanied by a rough sketch or a quick screen mock, just enough to anchor the intent. Then the real vibe-coding began: building, testing, prompting, re-prompting, fixing, refactoring, and repeating. The back-and-forth between idea, implementation, and behavior in the system was constant. I was using the product while building it, noticing where it felt off, where language collapsed, where structure leaked, and then adjusting both the prompts and the product in tandem.
Why Lovable?
I chose Lovable deliberately because it let me stay in that loop. It removed the friction between concept and execution and made it possible to treat the product as a living system rather than a static build. I did not want tooling that forced premature rigidity or pushed me into false precision. I wanted something that supported exploration without sacrificing structure. That combination, free-form thinking up front, lightweight but explicit PRDs, and fast, iterative execution, is the same way I have designed teams and products for years. PathPilot is simply that process made visible, with AI as an active collaborator rather than a black box.
Where It’s Headed Next
There is still so much ahead, from deeper integrations with job platforms to evolving the assistants, to enabling agentic workflows that take care of the tedious steps between intention and outcome. But the core will stay the same.
PathPilot is built to help people express who they are, with confidence, clarity, and authenticity. This is the kind of work that I care about because it is the kind of work that actually changes lives.
And it all started with a few experiments that refused to stay small.
For more info: https://pathpilot.pro
Or, sign up here: https://app.pathpilot.pro
