Agentic Product Manager

Talk to a Grok Bot about an idea and a team of AI agents plans it, Cursor writes the code, and Grok Bot tests the live app. You approve every step before anything ships.

Comment

Inspiration

What it does## Inspiration

I get a new idea almost every day, and most of them come when I'm away from my computer: driving, walking, doing something else. Turning an idea into working software is slow, because a good product is more than code. It needs a PRD, acceptance criteria, UX and architecture decisions, a task plan, code review, QA and a release decision.

Many people skip those steps. A non-technical founder who "vibe codes" usually gets a pile of code with no structure behind it. I wanted a way to talk to one assistant, even hands-free, and get a product built properly, with every step of a real team's process.

What it does

SharkByte lets you build a product by talking to a Grok Bot. You only talk to Project Lead. A team of AI agents does the rest.

  1. Idea Lab: agents score the idea, research the market, check feasibility and cut it down to a small MVP.
  2. Deep Dive: a Product Owner, Product Manager and UX Researcher write the PRD, user stories and acceptance criteria.
  3. Design: an Architect, UX/UI Designer, Security Reviewer and MVP Cutter debate the stack, data model and pages.
  4. Plan: a Tech Lead breaks the design into small tasks, and a Cursor Prompt Writer turns each one into a task file for a coding agent.
  5. Build: Cursor Cloud Agents write the code, run it and open a PR, one task at a time.
  6. Review, QA and vote: reviewer agents check the diff, a QA Tester bot tests the live Vercel preview like a real user and sends screenshots, and a voting panel decides Go or Hold.
  7. Release: nothing merges or deploys until you say "Go" in the chat.

It works for two kinds of people:

  • A non-technical founder who doesn't know how to vibe code well. They describe the idea in plain words, answer questions and approve. The agents handle the structure.
  • A technical builder who cares about how the project is run. Every decision, document and task is in GitHub (issues, labels, docs/, tasks/, PRs), so they can follow along and step in whenever they want.

You can also add features later by saying something like "add a daily vocab quiz". That goes through a shorter story, plan, build and review path.

How I built it

  • Swarms API is the brain. Every agent that thinks, plans, reviews or votes runs in Swarms, and each phase uses the swarm type that fits it:
    • ConcurrentWorkflow for Idea Lab and Code Review, where the views are independent.
    • HierarchicalSwarm for Deep Dive, where the Product Owner leads.
    • GroupChat for Design, where trade-offs need debate.
    • SequentialWorkflow for Plan, Release and the feature story, where each step refines the last.
    • MajorityVoting for the Release Vote.
  • Cursor Cloud Agents are the hands. They read the project rules and one task file, write the code, run the app and tests, and open a PR with evidence.
  • Grok Bot is the voice and the eyes. Three bots: Project Lead (the only one I talk to), Progress Reporter (updates with screenshots) and QA Tester (tests previews against the acceptance criteria). They talk to the system through webhooks.
  • GitHub Actions and a Python orchestrator connect everything. The orchestrator has no memory between runs, because the repo is the memory: issues, labels, docs, tasks and PRs.
  • Vercel gives every PR a preview and deploys production on merge.

The core rule is agents decide, code acts. A Swarms agent can say "merge this PR", but only the orchestrator calls the GitHub API, and only after I approve in the chat. Cursor Cloud Agents write all of the product code. Claude Code wrote the orchestrator code.

Challenges I ran into

  • Swarms gateway limit: the API answers 503 after about 30 seconds even though the swarm keeps running. I built a recovery path that finds the finished job by its unique name and fetches the result, with no re-run and no double billing.
  • Agents are unpredictable: in GroupChat, which agents speak and how often changes from run to run. Output isn't always valid JSON. Every phase now ends in a fixed JSON contract, with a Formatter agent as a fallback.
  • Reviewers that cried wolf: the first Code Review run flagged a correct import as a high-severity bug and a placeholder string as a leaked secret. I added a Verifier pass that rechecks every high finding against the diff before it can block a release.
  • Vercel doesn't send deployment_status events, so I trigger on commit statuses and read the preview URL from the Vercel bot's PR comment.
  • Making a bot-driven flow safe: only the repo owner can issue commands, user text never goes through ${{ }} in shell steps, and secrets never go into agent prompts.

Accomplishments that I'm proud of

  • A real conversation, with no commands to learn, that goes from "I have an idea" to a PRD, a design, a task plan and a Cursor PR in a new repo.
  • Human approval gates between phases, so the agents never ship without a clear "Go".
  • The state lives entirely in GitHub, so there's no database and no server to run.

What I learned

  • Each Swarms swarm type has its own output shape, so the parsing has to be designed per type.
  • AI reviewers need a second pass that checks their claims against the code.
  • Splitting the work into "think" (Swarms), "do" (Cursor) and "talk and test" (Grok Bot) kept each part simple.

What's next

  • Run the full review, QA, vote and release flow end to end on the live English-learning demo app.
  • Add a morning digest of the best ideas and a bug-triage agent.
  • Support teams, not just solo builders.

Built With

  • claude-code
  • cursor
  • cursor-cloud-agents
  • figma
  • github-actions
  • github-api
  • grok
  • grok-bot
  • markdown
  • next.js
  • openrouter
  • postgresql
  • pygithub
  • python
  • requests
  • supabase
  • swarms-api
  • vercel
  • webhooks
Share this project:

Updates

Submission history