The New PM Stack: Brainstorm, Plan, Execute, Design
6 min readPublished By Ofer Regev
A request lands on your desk: build a competitor analysis dashboard with external vendor data. A year ago that meant a ticket, a backlog and a wait. Now you can have a working version in hours.
The catch is that "I used an AI tool once" isn't a workflow. This piece is about the workflow: what tools to start with, when to leave them, and the loop that makes the result repeatable.
Start with the landscape
Chat-based builders are the fastest way to see an idea running, and each one suits a different person:
Tool
Built for
Good at
V0
Designers and front-end devs
Clean React/Next.js UI from prompts
Lovable
PMs and founders
Full-stack web apps, end to end via chat
Base44
Non-technical builders
Apps with a backend and zero setup
Google AI Studio
Experimenters
Quick AI-powered prototypes on Gemini
Use them. But at some point you'll hit a wall: you can't extend the tool, you can't reuse what you did, and you're working in a sandbox instead of a real repo.
The next level: skills plus an agentic IDE
The step up is an agentic workspace: Antigravity, Claude Code or Cursor. Three things change:
Real file and codebase access. You work on actual repos, not sandboxed output.
Skills. Reusable workflows you encode once and trigger forever.
One place. The agent that plans is the agent that builds.
A skill is a teammate's playbook. It's a SKILL.md file with a description, triggers and step-by-step instructions. It activates from natural language, so there are no commands to memorize, and skills can call other skills. Yours to write: your PRD process, your launch checklist, your retro template.
The loop: brainstorm, plan, execute
Here's the same example run through three skills in order.
Brainstorm."I want to add competitor monitoring to our PM hub. Help me brainstorm." The skill triggers, asks clarifying questions about the target user, constraints and jobs to be done, and returns ten ideas, each with a hypothesis, value, effort and risk. It also surfaces angles you didn't consider, such as data freshness, alerts and share-out.
Plan."We picked the top idea. Turn it into an implementation plan." It picks up the brainstorm output and asks about scope and must-haves. It produces phases, milestones and risks, broken into bite-sized steps. This is the step that bridges "great idea, now what?"
Execute."Take this plan and start building, task by task." It turns the plan into an explicit task list and works through one task at a time, checking in so nothing drifts. The output is a working prototype.
The point isn't any single skill. It's that each output is structured enough to feed the next one.
Heavy or light?
Two families of skill packs cover this:
BMAD Method
Lightweight skills (Superpowers, GSD)
Philosophy
Full SDLC with dedicated agent personas
Composable, one-shot accelerators
Structure
Analyst → PM → Architect → Dev hand-offs
Mix and match, no fixed flow
Best for
Full product builds with rigor
Fast iteration, PM workflows, demos
Weight
Heavy: sets up a whole process
Light: invoke a skill, get a result
My daily driver is the lightweight kind: faster and more flexible. I'd reach for BMAD when a project genuinely demands the full process.
And don't write everything yourself. skills.sh works like an app store for skills: browse by category, install in one line, and drop them into Antigravity, Claude Code or Cursor.
Design where you build
The last piece is design. Two tools worth knowing:
Claude Design
Stitch (Google)
Speed to first output
Slower, conversational
Very fast, mockups in seconds
Control
High: refine in natural language
Lower: regenerating often beats iterating
Code
Strong: outputs ship as real components
Weaker: designs need translating to code
Best for
Design-to-implementation, real handoff
Quick visual exploration
Rule of thumb: speed, use Stitch. Real handoff, use Claude Design.
Better still is designing where you build. A design skill in your IDE means no tool-switching, outputs that are real components, and design tweaks made through conversation with the same agent that writes the code. Encode your style guide and components once, and apply them everywhere.
The stack in one line
Brainstorm (ten ranked ideas) → Plan (a structured plan) → Execute (a working prototype) → Design (production-ready UI) → Validate, and the loop continues.
This week
Install Antigravity, Claude Code or Cursor.
Browse skills.sh and add three skills to your stack.
Pick one real problem on your plate and vibe-code it before Monday.
Learning isn't shipping. A PM with skills and an agentic IDE is a one-person product team.
