A battle-tested workflow that enables Product Managers and other non-engineers to transform product requirements into production-ready code through structured AI collaboration.

Write a PRD. Run 11 commands. Ship features with tests, documentation, and security review.

Time: Significantly faster delivery for routine features (50-75% time savings typical) Quality: 90%+ test coverage, automated security review, comprehensive documentation Output: Production-ready code that integrates cleanly with existing codebases

Traditional product development bottlenecks on engineering capacity. AI coding tools promise speed but without structure create unmaintainable chaos—duplicate code, security holes, missing tests, and technical debt.

This workflow provides the structure AI needs to help non-engineers move beyond prototypes and build production software reliably:

1. Service Inventory System Automatically catalogs existing code before building anything new. Prevents the #1 AI coding disaster: rebuilding functionality that already exists.

2. Adaptation Phase Transforms "what exists" into "how to build this feature." AI gets explicit guidance on which services to reuse and how to integrate with existing patterns.

3. Automated Ticket Memory Your ticketing system (Linear/Jira) becomes AI's external memory. Discovery findings, architectural decisions, and implementation guidance persist across sessions—and you can read and verify everything AI knows.

4. Specialized Agent Workflow Instead of one generic AI, you work with expert agents—architect, backend engineer, QA, security, technical writer. Each focuses on their specialty with strict boundaries to prevent scope creep.

5. Auto-Activated Quality Skills (Claude Only) Skills enforce standards during development, not just at review time. Production code standards, security patterns, and testing philosophy activate automatically as Claude writes code—preventing issues before they're created.

6. Production-First Quality Focus Zero tolerance for workarounds, fallbacks, or temporary solutions. Risk-based testing focuses on code that matters. Inline documentation AI can't miss. Strong guidance to fail fast and fix issues rather than building workarounds you'd otherwise miss.

• Prevent duplication: Service inventory catches 60-75% code reuse opportunities
• Maintain quality at scale: Built-in gates ensure code remains maintainable as applications grow
• Move faster on routine work: Handle straightforward features without bottlenecking on engineering
• Preserve engineering focus: Engineers tackle complex challenges while AI handles CRUD operations

Perfect for:

• Product Managers leading technical teams who want to accelerate delivery
• Technical PMs who want to multiply their output on routine development
• Solo founders building MVPs with AI assistance
• Engineering leaders enabling non-technical staff to contribute safely

Best suited for:

• Internal tools and operational software
• MVPs and prototypes that evolve into products
• Standard web applications with common patterns
• Features for existing codebases following established conventions

Requires additional engineering expertise for:

• Mission-critical systems where failures have serious consequences
• Highly regulated industries (healthcare, finance) requiring deep compliance review
• Novel architectures or cutting-edge technology integration
• Systems requiring significant performance optimization

This workflow helps PMs and other non-engineers build software that works in production—with proper tests, documentation, and security review.

It will not produce the elegantly architected, concise, highly scalable code that senior engineers would write.

It will enable you to ship real features, maintain code quality as your application grows, and avoid the unmaintainable mess that unstructured AI coding creates.

The honest truth: AI-assisted development with proper quality gates produces reliable software for many use cases. It does not replace the judgment of experienced engineers for complex systems. Use this workflow for appropriate projects, and involve engineering expertise when stakes demand it.

The workflow consists of three phases:

1. /generate-service-inventory - Catalog existing code (run after major codebase updates)
2. /discovery - Analyze patterns and architecture (run before each epic planning phase)
3. /epic-planning - Create business-focused epics (run for each new feature, PRD, or major initiative)
4. /planning - Decompose epics into engineering tickets (run for each new epic)

/execute-ticket [ticket-id] - The recommended approach for ticket-level work

One command orchestrates all six phases automatically:

• Creates feature branch using Linear's branch naming
• Runs adaptation, implementation, testing, documentation, code review, and security review
• Creates draft PR after implementation, converts to ready when security passes
• Adds PR labels and phase comments for full traceability
• Pauses only for blocking issues (failing tests, security vulnerabilities)

Why use the agentic workflow:

• 8x faster than running phases manually
• Zero human intervention for tickets that pass all quality gates
• Consistent quality across all tickets
• Full traceability with PR comments and labels
• Resume capability if interrupted

For special cases requiring phase-by-phase control:

5. /adaptation - Create implementation guide (reuse analysis, pattern selection)
6. /implementation - AI writes production code following guide
7. /testing - Build and fix comprehensive test suite until passing
8. /documentation - Generate API docs, user guides, inline documentation
9. /codereview - Automated quality checks and pattern compliance
10. /security-review - OWASP vulnerability scan → closes ticket when passing

Use individual phases when you need to:

• Debug a specific phase that failed in agentic execution
• Run only certain phases (e.g., just testing and security review)
• Manually intervene between phases

11. /close-epic - Close completed epic with retrofit analysis → closes epic when all tickets done

Each phase includes quality gates. Security review is the final gate that marks tickets as complete. Epic closure is the final gate that marks epics as complete after all sub-tickets pass.

Best practice: Run each command in a fresh Claude Code session to prevent context overflow and ensure optimal performance.

For Claude Code Users (Recommended):

• Standard git branches, one ticket at a time → Installation

For OpenAI Codex Users:

• Platform-agnostic prompts in codex/prompts/ → Codex Guide

• AI coding tool (Claude Code or OpenAI Codex)
• Ticketing system with MCP integration (Linear recommended, Jira and other systems with MCP integrations supported)
• Git repository
• Complete prerequisite checklist

Install from Claude Code Marketplace:

# Add the marketplace first
/plugin marketplace add bdouble/pm-vibecode-ops

# Then install from marketplace
/plugin install pm-vibecode-ops@pm-vibecode-ops

When prompted, select "User" scope to make the plugin available across all projects.

That's it! The plugin system automatically installs all commands, agents, skills, and hooks.

Scope options explained:

• User (recommended) - Available in all projects for you
• Project - Available to all collaborators in this repository (commits to .claude/settings.json)
• Local - Available only in this project, only for you

What gets installed:

• Commands (/adaptation, /implementation, etc.) - Explicit workflow phases you invoke
• Agents - Specialized AI roles (architect, QA engineer, security engineer)
• Skills - Auto-activated quality enforcement during development
• Hooks - Session automation for workflow context

For OpenAI Codex users: See Codex Guide for platform-agnostic prompts.

MCP configuration (Linear, Perplexity, etc.): docs/MCP_SETUP.md First-time terminal users: docs/SETUP_GUIDE.md

1. Write a PRD with clear success criteria → Writing AI-Friendly PRDs
2. Run project-level commands (inventory, discovery, epic planning, technical planning)
3. Run /execute-ticket [ticket-id] for each ticket - one command handles all phases automatically
4. Merge when all quality gates pass

Detailed walkthrough: GET_STARTED.md

Start here if you don't have a development background:

• PM_GUIDE.md - Complete workflow guide with non-technical explanations
• GET_STARTED.md - Quick start and navigation guide
• EXAMPLES.md - Real-world case studies showing the workflow in action
• FAQ.md - Common questions and troubleshooting
• GLOSSARY.md - Technical terms explained for PMs

Detailed command syntax and architecture:

• TECHNICAL_REFERENCE.md - Complete command documentation, agent specifications, architecture details
• SKILLS.md - Auto-activated quality enforcement (production standards, security patterns, testing philosophy)
• INSTALLATION.md - Comprehensive installation guide

Based on workflow capabilities and user experiences:

Speed:

• 50-75% reduction in development time for routine features
• Faster iteration cycles (hours to days vs. days to weeks)
• Reduced time-to-production for well-defined requirements

Quality:

• 90%+ test coverage achievable consistently
• Automated security review catches vulnerabilities before production
• Comprehensive documentation generated automatically
• Code follows existing patterns and conventions

Team Impact:

• PMs can ship routine features without bottlenecking engineering
• Engineers focus on complex challenges requiring human expertise
• Reduced context switching for development teams
• Better alignment between product requirements and implementation

Process Benefits:

• Service inventory prevents code duplication (60-75% reuse typical)
• Quality gates ensure consistent standards
• Clear audit trail from requirements to deployment
• Predictable delivery timelines for appropriate features

See educational walkthroughs demonstrating the workflow

• Questions? Start with FAQ.md - 50+ answered questions
• Stuck? Check docs/TROUBLESHOOTING.md
• Issues? Open an issue on GitHub
• Contributing? CONTRIBUTING.md

This work is licensed under a Creative Commons Attribution 4.0 International License.

You are free to share and adapt this material for any purpose, even commercially, as long as you give appropriate credit. See the LICENSE file for full details.

Ready to transform how you build software? Start with PM_GUIDE.md or jump straight to GET_STARTED.md.