A copy-paste workflow that turns any AI coding assistant into a disciplined dev team. 7 commands, 15 practices, zero vendor lock-in.
Every AI coding tool promises 10x productivity. But without process discipline, you get 10x chaos: half-baked features, no tests, decisions nobody remembers making, and code that breaks when you sneeze.
I synthesized practices from Google SRE, DORA research, Martin Fowler, the Linear Method, and real-world AI dev workflows into something I actually use every day. This repo is that workflow, packaged so you can drop it into any project.
7 slash commands that enforce a disciplined build loop:
| Command | What It Does | Tier |
|---|---|---|
/explore |
Deep analysis before coding (NO CODE rule) | All |
/plan |
Turn an issue into an executable plan | All |
/build |
Implement with TDD in small batches | All |
/review |
Cross-model code review (SHIP/REVISE/BLOCK) | All |
/retro |
Postmortem learning (5 Whys) | All |
/rfc |
Architecture decision record (ADR) | Team+ |
/handoff |
Context transfer (SBAR format) | Team+ |
15 elite practices, tiered so you're not boiling the ocean:
- Tier 1 (Solo): 5 essential practices -- trunk-based dev, TDD, small batches, strategy-execution split, cross-model review
- Tier 2 (Team): 10 practices -- adds feature flags, postmortems, observability, compound learning, visual tracking
- Tier 3 (Enterprise): All 15 -- adds ADRs, multi-model validation, tiered teaching, workflow phasing, architecture review
Complete artifact system -- plans, decisions, knowledge, retros, RFCs, handoffs. Everything lives in git as markdown. No external tools required.
# Clone the repo
git clone https://github.com/bennjph/agentic-ai-dev-team-setup.git
# Copy the playbook into your project
cp -r agentic-ai-dev-team-setup/playbooks/product-development/* your-project/
# Choose your tier (edit config/TIER.md)
# Solo (1 dev) | Team (2-10 devs) | Enterprise (10+ devs)
# Configure AI models (edit config/PEER_REVIEW.md)
# Or set environment variables:
export OPENCODE_BUILDER_MODEL="openai/gpt-5-3-codex"
export OPENCODE_REVIEWER_MODEL="anthropic/claude-sonnet-4-5"
# Start your first workflow
/explore "Your first feature"
/plan
/build
/review
/retroFull guide: QUICK-START.md | SETUP.md
/explore enforces a NO CODE rule. You map the problem space, identify risks, and pick an approach -- before writing a single line. Code commits you to a solution before you understand the problem.
Builder uses Model A, Reviewer uses Model B (different providers preferred). Same model = same blind spots. Cross-model review catches things single-model can't.
Example: Builder (GPT-5.3) -> Reviewer (Claude Sonnet 4.5). Or Builder (Claude Opus) -> Reviewer (Kimi K2 Thinking).
The value is in the workflow discipline, not the tooling. These commands work with OpenCode, Cursor, Claude Code, or any AI assistant that reads markdown. If you switch tools, the workflow stays the same.
No hardcoded AI providers. Works with OpenAI, Anthropic, Google, DeepSeek, Moonshot, open-source models -- any combination. Configure via environment variables, switch anytime.
Start simple, scale up when needed:
| Tier | Team Size | Practices | Commands |
|---|---|---|---|
| Solo | 1 person | 5 essential | 5 core |
| Team | 2-10 people | 10 practices | 7 (adds RFC + handoff) |
| Enterprise | 10+ people | All 15 | 7 (stricter gates) |
"If you didn't update the artifacts, you didn't do the work."
Every command creates or modifies files in your repo. Plans, reviews, decisions, retros -- all version-controlled markdown. No oral tradition. Future devs understand "why" not just "what."
Plans use emoji for visual status: done, in progress, blocked, pending. Glanceable. No "what's the status?" meetings.
playbooks/product-development/
├── README.md # This file
├── QUICK-START.md # 15-min getting started
├── SETUP.md # Full configuration guide
├── WORKFLOW.md # How to use each command
├── PRACTICES.md # The 15 elite practices (with evidence)
├── AGENTS.md # AI agent configuration
│
├── .opencode/
│ ├── commands/ # 7 slash commands
│ │ ├── explore.md
│ │ ├── plan.md
│ │ ├── build.md
│ │ ├── review.md
│ │ ├── retro.md
│ │ ├── rfc.md
│ │ └── handoff.md
│ └── agents/ # 6 AI agent prompts
│ ├── orchestrator.md
│ ├── strategist.md
│ ├── builder.md
│ ├── reviewer.md
│ ├── analyst.md
│ └── writer.md
│
├── config/ # Configuration
│ ├── TIER.md # Solo / Team / Enterprise
│ ├── PEER_REVIEW.md # AI model selection
│ └── WORKING_AGREEMENTS.md # Team conventions
│
├── templates/ # File templates
│ ├── ISSUE_TEMPLATE.md
│ ├── PLAN_TEMPLATE.md
│ ├── ADR_TEMPLATE.md
│ ├── RFC_TEMPLATE.md
│ ├── HANDOFF_TEMPLATE.md
│ └── RETRO_TEMPLATE.md
│
├── docs/ # Project documentation
│ ├── PROJECT_BRIEF.md
│ ├── ARCHITECTURE.md
│ ├── TECH_STACK.md
│ ├── QUALITY_STANDARDS.md
│ └── REPO_MAP.md
│
└── [artifact directories]/ # Where work gets saved
├── backlog/ # Issues + explorations
├── plans/ # Executable plans
├── decisions/ # Code reviews + ADRs
├── rfcs/ # Architecture proposals
├── handoffs/ # Context transfers
├── retros/ # Postmortems
└── knowledge/ # Compound learning vault
You're building a SaaS product solo. Use the /plan -> /build -> /review loop with TDD and cross-model review. Ship faster with fewer bugs.
Five devs building a B2B app. Use all 7 commands. /rfc for architecture decisions, /handoff for context transfers, cross-model review with 2 AI models. Better coordination, less rework.
Fifty devs, multiple teams, high-stakes production. All 15 practices, multi-model review (3+ AI models from different providers), feature flags for gradual rollout, workflow phasing. Sustainable pace with institutional knowledge.
| Metric | Target |
|---|---|
| Time to ship feature | < 1 week |
| Test coverage | > 80% |
| Repeat incidents | < 10% |
| Code review turnaround | < 24 hours |
| Time to onboard new dev | < 1 day (with docs) |
Track monthly. Adjust process if metrics decline.
Yes. The commands are plain markdown. Copy them to Cursor (.cursor/commands/), Claude Code (.claude/commands/), or any tool that reads slash commands. The workflow is tool-agnostic by design.
No. Start with Tier 1 (5 practices) for solo work. Add Tier 2 when you have teammates. Add Tier 3 when you hit scale. The template adapts to your tier selection.
Not recommended. TDD is foundational. Without tests, refactoring and small batches become risky.
Peer review still works: self-review (same model, different prompt), time-delayed review, or human review. See SETUP.md for single-model configuration.
Start small. Adopt 1 command at a time. Show value before adding more. Week 1: /plan. Week 2: /review. Week 3: /build with TDD.
Copilot is code completion. Cursor is tool-specific. Linear is issue tracking. SCRUM has 2-week sprints. This is a full workflow (planning through review) that ships in small batches daily, works with any AI, and captures knowledge as you go.
Contributions welcome -- bug fixes, clarity improvements, new examples, tier-specific enhancements.
See CONTRIBUTING.md for guidelines.
MIT License. See LICENSE.
Synthesized from:
Created by: Benison Joseph