Aakash Gupta

The Claude Code Setup for Non-Technical PMs That Nobody Shows You

Most PMs are still bureaucrats stuck in Jira, Linear, and PowerPoints. The best PMs have stopped waiting on engineering and started shipping code themselves. In this episode, Andre Albuquerque (founder of Builders Camp, Europe's largest product builder school with 4,000+ students) walks through his exact 4-level builder PM stack live - Lovable, Claude Code, Cursor, Vercel, and a multi-agent CLAUDE.md setup that AI-native teams actually run. Full Writeup: https://www.news.aakashg.com/p/claude-code-non-technical-pms Transcript: https://www.aakashg.com/albuquerque-podcast/ --- Timestamps: 00:00 - Intro 02:27 - The biggest problem non-technical PMs face today 04:50 - The 4-level builder PM framework 05:28 - Level 1 - Why you start with Lovable 08:04 - Level 2 - The Lovable + Claude Code bridge 10:21 - Ads 12:14 - Live demo: connecting Lovable to Claude Code via GitHub 28:37 - Level 3 - Cursor + Vercel for real production 31:02 - Ads 33:22 - Why Andre prefers Cursor over Claude Code desktop 35:40 - Mental model: Lovable vs Cursor vs Vercel 41:17 - Level 4 - Agents, skills, and CLAUDE.md 42:50 - The CLAUDE.md memory file explained 45:24 - The PM orchestrator agent pattern 53:26 - How AI-native teams spend 50% of their time 01:01:33 - Why 90% of European PMs are still non-technical 01:07:45 - The Monday morning move 01:09:07 - Outro --- 🏆 Thanks to our sponsors: 1. Customer.io: Send smarter messages using your product data - http://customer.io/productgrowth 2. Amplitude: The market-leader in product analytics - https://amplitude.com/session-replay?utm_campaign=session-replay-launch-2025&utm_source=linkedin&utm_medium=organic-social&utm_content=productgrowthpodcast 3. Bolt: Ship AI-powered products 10x faster - https://bolt.new/solutions/product-manager?utm_source=Promoted&utm_medium=email&utm_campaign=aakash-product-growth 4. Ariso: Ariso: Your AI chief of staff for meetings, follow-ups, and coaching - https://ariso.ai/aakash 5. Product Faculty: Get $550 off their #1 AI PM Certification with code AAKASH550C7 - https://maven.com/product-faculty/ai-product-management-certification?promoCode=AAKASH550C7 --- Key Takeaways: 1. Non-technical PMs are stuck in Jira, Linear, and PowerPoints - Most European PMs are still product owners in disguise, paper-shuffling between strategy and engineering teams. The way out is to actually start building, not to lobby for more autonomy. 2. Start with Lovable on a personal project - Build something for your family, your friends, yourself. The codebase does not need to be pretty. The point is the safety to make mistakes without breaking anything that matters. 3. The Lovable + Claude Code bridge nobody documents - Connect both tools to the same GitHub repo. Write code in Claude Code with all its depth. QA visually in Lovable with its hosted preview. Publish from Lovable's button. The perfect transition layer. 4. Lovable, Cursor, and Vercel are not competitors - Lovable bundles the IDE, the hosting, and the deployment in one product. Vercel exposes the hosting layer so you can run real branches with real preview URLs. Cursor is just an IDE with a generous free tier. 5. Cursor has a free debugging agent - When Claude Code breaks, open a Cursor agent and paste the error. The free agent unsticks you instead of leaving you stuck at step zero. 6. CLAUDE.md is your team's culture - Loaded automatically every session. The first rule should be "for every task, call the PM agent." When you notice yourself fixing the same issue twice, update CLAUDE.md so it never happens again. 7. The PM agent never writes code - The PM orchestrator's only job is to decide which other agent should handle the work. The researcher investigates. The designer proposes. The engineer architects. The implementer writes. 8. Do not copy famous people's skills wholesale - Going on LinkedIn and downloading 100 skills from product celebrities creates more confusion than value. Look at how your real team works. Write each role down as an agent. 9. Fix the agent, not the feature - When something ships wrong, do not patch the output. Identify which agent in the pipeline failed, update its instructions, and run the pipeline again. The next session inherits the fix. 10. The Monday morning move is exactly three steps - Get added as a collaborator on a low-risk repo. Pick the oldest ticket in the backlog. Push a branch and demo by Friday. --- 👨‍💻 Where to find Andre Albuquerque: LinkedIn: https://www.linkedin.com/in/andre-albuquerque/ Builders Camp: https://builderscamp.com Newsletter: https://www.andrealbuquerque.com 👨‍💻 Where to find Aakash: Twitter: https://x.com/aakashgupta LinkedIn: https://www.linkedin.com/in/aagupta/ Newsletter: https://www.news.aakashg.com #BuilderPM #ClaudeCode #AIPM --- 🧠 About Product Growth: The world's largest podcast focused solely on product + growth, with over 200K+ listeners. 🔔 Subscribe and turn on notifications.

AAAndre AlbuquerqueguestAGAakash Guptahost

May 18, 2026·1h 10m·Watch on YouTube ↗

📖 CHAPTERS

1. 1

   Why non-technical PMs are becoming “bureaucrats” (and why that’s dangerous now)

   Andre frames the core issue: many non-technical PMs are trapped in tools like Jira/Linear and decks, fully dependent on engineering to ship. He contrasts this with AI-native teams where PMs and even CEOs contribute directly to code and production changes. The chapter sets the urgency: PMs who don’t build risk being left behind.

2. 2

   The 4-level “Builder PM” roadmap: Lovable → Bridge → Production → Agents

   Andre introduces the progression he used personally to go from non-coder to shipping: four levels that gradually increase technical surface area. The emphasis is comfort and pragmatism—adding complexity only when it solves a real constraint. This becomes the episode’s organizing framework.

3. 3

   Level 1 — Starting with Lovable for low-risk, fast learning

   Andre explains why Lovable is the best on-ramp: it’s visual, less intimidating than an IDE, and abstracts away foundational infrastructure. He recommends starting with a personal project to remove organizational risk and allow experimentation. The goal is building confidence and intuition, not perfect code.

4. 4

   Level 2 concept — Using Lovable as “QA + hosting” while Claude Code does the heavy lifting

   Andre shares an unconventional but powerful workflow: keep Lovable as the place you visually test and host, while making code changes in Claude Code and syncing via GitHub. This creates a gentle transition: more coding power without needing to learn deployments or infra yet. It also enables fast QA because changes appear back in Lovable after merges.

5. 5

   Live demo walkthrough — Connecting Lovable to Claude Code through GitHub

   Step-by-step, Andre bootstraps a new Lovable app, connects it to a GitHub repo, then opens that repo inside Claude Code. He demonstrates making UI changes in Claude Code, merging them, and watching Lovable update with the new version. The demo makes the “bridge” workflow concrete and repeatable.

6. 6

   Non-technical Git basics (without the intimidation): branches, PRs, merging

   Aakash gives a simplified explanation of how branching and pull requests work, focusing on what a PM needs to know to follow the flow. Andre reinforces that for personal projects you can skip formal review, but company workflows will require adapting to team pipelines. The takeaway: you can ask Claude Code to handle the mechanics even if you don’t know the terms.

7. 7

   Publishing & preview links in Lovable: what updates automatically vs what needs “Publish”

   Andre clarifies a key gotcha: code merges can update the Lovable preview environment, but the public link only updates after you publish. He shows how preview links help QA on different devices and share with others before going live. This makes Lovable a lightweight staging workflow for beginners.

8. 8

   Level 3 — Graduating to real production: Vercel previews, branches, and safer velocity

   Andre explains why he eventually moved off Lovable: to work faster and more safely with multiple branches and parallel work. Vercel becomes the standard bridge from GitHub to users, automatically creating preview deployments per branch. This is where the workflow starts to resemble professional product engineering.

9. 9

   Why Andre uses Cursor (with Claude Code) instead of Claude Code desktop

   Andre describes preferring Cursor’s interface and visual comfort—especially the vertical session view—while still using Claude Code for the actual agent/coding capability. Aakash adds practical reasons: Cursor’s generous free plan and helpful debugging via Cursor agents. The chapter frames Cursor as an ergonomic layer, not a requirement.

10. 10

    Mental model: Lovable vs Claude Code vs GitHub vs Vercel (who does what?)

    Aakash pushes for a clear conceptual map, and Andre explains the “bridge” model: Claude Code is where you generate changes, GitHub is where code lives, and Vercel connects that code to users via deployments. Lovable is primarily an AI builder/IDE, but can act like a simplified hosting + QA layer in the earlier stages. This chapter reduces tool confusion by assigning each tool a role.

11. 11

    Level 4 — Building your “machine”: agents, skills, and the CLAUDE.md memory file

    Andre addresses the fear of “slop” from vibe coding by introducing a structured agent system. He explains CLAUDE.md as a persistent rulebook/culture that loads every session, plus optional agents and skills that get invoked intentionally (or via rules). The goal is to standardize quality and free humans to focus on problem discovery and decisions.

12. 12

    The PM orchestrator agent pattern: how tasks route to specialist agents

    Andre walks through his “PM agent” that orchestrates work rather than doing it—mirroring how PMs coordinate specialists. The orchestrator decides when to call a designer for UX questions or an engineer for architecture checks, then compiles outputs and questions back to the user. This turns a single builder into a small virtual product team.

13. 13

    How AI-native teams spend time: 50% building the product, 50% improving the system

    Andre explains a key operating shift: the best teams invest heavily in improving the agent/skill infrastructure so each future build is higher quality and faster. Engineers improve engineering agents, designers improve design agents, PMs improve orchestration and decision frameworks. The compounding effect enables very small teams to ship at high velocity.

14. 14

    Avoiding “slop”: quality gates (infra/security) + better problem framing (PM process)

    To counter the downsides of speed, Andre argues for two defenses: strong infra/security checks at the end of the pipeline, and stronger discovery/requirements rigor at the start. He describes using skills tied to product frameworks (JTBD, Opportunity Solution Trees, MoSCoW) to force better thinking before building. He also reframes collaboration: align heavily at the start and end, not during execution dependencies.

15. 15

    Europe vs US PM culture—and the “Monday morning move” to become a Builder PM

    Andre critiques Europe’s product-owner-heavy culture as delivery-management without technical leverage, leading to disempowered squads and siloed decision-making. He encourages PMs to influence change locally via small experiments, allies in engineering/design, and updated rituals that include the whole team. For immediate action, he recommends asking an engineer for collaborator access to a low-risk repo and using Claude Code to tackle an old backlog item on a branch—just to experience the new power firsthand.