JournaLens: my first build

Code on tap

The Mental Block

Before JournaLens, I had tried vibe coding and quietly given up.

In honesty, I hadn't tried very long. I had a mental block, and it was built from things engineers around me kept saying: it makes mistakes, you'll spend your time debugging its code. I had written code a decade ago, and I remembered enough to know what that meant. Debugging someone else's code is not a beginner's job. It takes a level of proficiency I did not possess.

So I filed it under “not for people like me,” and moved on.

The Excuse

Then Google DeepMind launched the Vibe Code with Gemini 3 Pro hackathon with Kaggle. Gemini 3 Pro had just shipped, the buzz was everywhere, and the format was simple: take their agents course, finish it, then build a project with Google AI Studio.

What got me wasn't the prize. It was the framing: this was specifically a vibe-coding hackathon. An official invitation to build the way I'd already decided didn't work.

I still didn't trust it. So I built myself a safety net: I roped in Joel, a backend developer from my own team at Wrike. The plan was the classic division of labour, the one I'd run my whole career. I would own requirements and the ideal state, maybe make some good-looking non-functional prototypes. Joel would do the heavy lifting: the actual code, the actual implementation.

The Idea

Google Maps gets you to a monument, then quits. You're standing in front of something five centuries old with no guide, signage you can't find, and no way to ask what that carving means. We wanted to build the missing half: context, at the monument, the moment curiosity shows up.

Tour→Capture→Annotate→Journal

The plan, in four moves: generate a walking tour on arrival. Photograph anything you can't name and have the model explain it. Turn the photos into labelled sketches. Stitch the visit into a journal. That was the whole spec.

Saturday night. Two laptops. Then we started work.

The Setup That Wouldn't End

Joel wasn't comfortable building inside AI Studio. Fair: this was his first AI product too, and he wanted the ground he knew, his own machine, his own environment. So he began the tedious ritual every developer knows: setting up the coding environment.

While he installed things, I tried the obvious approach in AI Studio: describe the app, see what comes out.

It was bad.

Two hours in, the environment still wasn't ready. And this is the moment the whole story turns on, though it didn't feel like it: bored, waiting, with nothing to lose, I opened AI Studio again and tried the opposite of vague.

The Mega Prompt

Screen by screen, I defined everything. Every interaction. What each screen must do. Which button leads where. One page at a time, all of it in one mega prompt. The goal was modest: get a prototype going while the real setup finished.

When AI Studio finished its run, it had one-shotted about 70% of the app we had planned.

Over the next two hours of prompting, I took it to roughly 80% of what JournaLens is today: the generated walking tour, the photograph-a-carving flow, the annotated sketches, the journal at the end.

A light bulb went off. I'm sure the code quality wasn't amazing. That was never the point. The point was that a person who cannot debug a stack trace had just talked a working product into existence in an evening. Code on tap, the unlock everyone had been raving about, and I had heard it a hundred times without internalising it once.

It took one Saturday night to undo a year of secondhand opinions.

What JournaLens Became

The app we shipped that weekend, move by move:

1. The tour Generated on arrival: checkpoints, and something worth noticing at each one. Every checkpoint opens its own chat, context already loaded.

   

2. Capture Photograph a carving, a symbol, a detail. Gemini 3 Pro names it, explains it, and ties it back to the building's story.

   

3. Annotate Photos become hand-drawn, labelled sketches: the bet being that some things stick when drawn that never stick when described. Its artifact is the cover image at the top of this page.
4. The journal The visit stitched into something you keep: checkpoints, annotated images, what you actually understood.

   

The repo is public, and the app runs in AI Studio. It is not a polished product. It is something better: proof.

How You Should Start

Since that weekend I haven't stopped. Over the next six months I moved from AI Studio to Claude to Codex to Cursor, and ended up with a full stack picked per task (written up here). Along the way: a feedback-intelligence app for discovery at work, a PM OS that automates my working processes, a Finance OS for personal finance, an agent-harness prototype for forms. The learning never stopped, because each build outgrew the platform before it.

Which is the actual answer to the question this page sits under:

• Start at a platform that meets your current skill level. AI Studio, Replit, Lovable: the built-in previews and simplified UI exist precisely so your first session produces something you can see.
• Be specific. Vague prompts got me garbage; the mega prompt got me 70%. Specificity is the skill, and it is a PM skill you already have.
• Graduate deeper only when your use case outgrows the platform, not because everyone on your feed uses a terminal. If you haven't coded in a decade, a terminal-first session hands you too many unknowns at once. Even Claude Code and Codex now have apps that are easy to start with when you're ready.
• Don't wait for a defined end state. How much a PM should build is as undefined as the PM role itself; every company wants something different. The capability is what's essential.

That covers where to begin. The how (baseline, gaps, real pieces, prototype) is Part 2's ladder, and it works from any platform on this list.

The tipping point has already passed. The only question is when you notice.

Sources The hackathon (Vibe Code with Gemini 3 Pro in AI Studio) · The course (5-Day AI Agents Intensive Course with Google, capstone project) · The artifact (JournaLens on GitHub, live AI Studio demo)