{
  "markdown": "# Virtual Team\n\nA development-agent plugin that turns Claude Code or Codex into a virtual development team. It provides a deliberate pipeline from idea to shipped code — with agents, commands, and skills that enforce TDD, contract-first development, and quality gates at every step.\n\n## Supported hosts\n\n| Host | Integration | Status |\n|---|---|---|\n| Claude Code | Slash commands, skills, agents, and hooks | Native |\n| Codex | Plugin manifest, workflow skills, shared skills, and subagent adaptation | Native |\n\n## Getting Started with Claude Code\n\n### 1. Install the plugin\n\nIn a Claude Code session, run:\n\n```\n/plugin marketplace add ovargas/virtual-team\n/plugin install virtual-team@virtual-team-marketplace\n```\n\n### 2. Initialize your project\n\nStart a Claude Code session and run:\n\n```\n/virtual-team:start\n```\n\nThis walks you through an interactive interview to define your tech stack, project structure, and conventions. It creates `stack.md` (the source of truth for your project) and sets up the `docs/` directory structure.\n\nAnything you haven't decided yet gets marked as TBD — the architect agent will catch it later when a feature actually needs it.\n\n> **Working on multiple repositories?** You can create a hub repo to coordinate across services — shared decisions, epics, and API contracts in one place. Run `/virtual-team:start --hub` in a new repo to set it up. See the [command reference](docs/command-reference.md#multi-repo-setup) for details.\n\n### 3. Start building\n\nYou only need **5 commands** for daily work:\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:status` | Start your day — shows what's in progress, what's next |\n| `/virtual-team:flow <description>` | Build a feature end-to-end (spec → plan → code → review → PR) |\n| `/virtual-team:flow --fix <description>` | Fix a bug end-to-end (report → investigate → fix → review → PR) |\n| `/virtual-team:commit` | Create a clean, atomic commit |\n| `/virtual-team:handoff` | End a session — captures state for the next one |\n\nThat's it. Everything else is optional.\n\n## Getting Started with Codex\n\nAdd this repository as a plugin marketplace and install Virtual Team:\n\n```bash\ncodex plugin marketplace add ovargas/virtual-team\ncodex plugin add virtual-team@virtual-team\n```\n\nRestart the Codex app and begin in a new task so the installed Skills are discovered. You can then ask Codex naturally or invoke a workflow explicitly, for example:\n\n```text\nUse virtual-team:workflow-start to initialize this repository.\nUse virtual-team:workflow-flow to add password reset by email.\nUse virtual-team:workflow-status to summarize current work.\n```\n\nCodex loads the same canonical workflow specifications used by Claude Code. The `workflow-*` adapters under `skills/` translate command invocation, tools, subagents, and permission boundaries without duplicating workflow logic. See [Codex installation](.codex/INSTALL.md) for migration from the previous symlink installation.\n\n### Working with an existing codebase?\n\nIf your project has been around for years and you're adopting this plugin retroactively, the workflow is the same — but you'll spend the first few sessions **documenting what already exists** rather than deciding fresh. **Nothing in your code changes during onboarding.** The plugin only adds documentation (`stack.md`, `docs/`) alongside your existing code.\n\nRun this sequence the first time you open the repo:\n\n| # | Command | Why |\n|---|---------|-----|\n| 1 | `/virtual-team:start` | Generates `stack.md` from what already exists. It reads `go.mod` / `package.json` / `pyproject.toml` / etc. and pre-fills the interview — you confirm what's there instead of deciding from scratch. Anything genuinely inconsistent across the codebase gets marked `TBD` and resolved later when a feature touches it. |\n| 2 | `/virtual-team:doctor` | Audits `stack.md` against available skills. Surfaces which technologies in your stack have no coding-convention skill yet — so you know where the LLM will be working without guardrails. Read-only, never blocks. (Runs once automatically at the end of `/start`; re-run after editing `stack.md`.) |\n| 3 | `/virtual-team:tech-review` | Baseline health reading — architecture drift, technical debt, dependency health, test coverage and security gaps. Output goes to `docs/reviews/` and becomes your first backlog candidates. Skip if you don't need an audit. |\n| 4 | `/virtual-team:docs` | Captures the tribal knowledge — setup guide, deploy guide, config reference — that's lived in people's heads. Years-old projects rarely have current docs. |\n| 5 | `/virtual-team:flow <new feature>` | Resume normal workflow. From here, every new feature uses the full pipeline; old code stays as-is until you touch it. |\n\nA few tips specific to legacy code:\n\n- **Don't retrofit conventions everywhere.** The plugin grows consistency at the edges where work happens. Trying to make the entire codebase match `stack.md` before any feature work is a death march.\n- **Set `tdd: recommended`, not `strict`.** Legacy code often can't be test-driven without large refactors. `recommended` mode (in `stack.md` Workflow section) lets the TDD skill adapt instead of blocking.\n- **Capture decisions just-in-time.** When you hit a \"why on earth did we do X\" moment during feature work, write an ADR in `docs/decisions/` then. Don't backfill every historical decision upfront — only record ones that are hard to reverse, surprising without context, AND a real trade-off.\n\n## Daily Workflow\n\n### Start your day\n\n```\n/virtual-team:status\n```\n\nShows what's in progress, what's blocked, and suggests the right command to run next.\n\n### Build a feature\n\n```\n/virtual-team:flow Add password reset via email\n```\n\nThis runs the full pipeline in one session:\n\n```\n/feature → /contracts → /plan → /implement → /review + /validate → /pr\n```\n\nInteractive gates between each step resolve decisions and TBDs without leaving the session. If the session is interrupted, just run `/virtual-team:flow` again — it auto-detects where you left off.\n\n### Fix a bug\n\n```\n/virtual-team:flow --fix \"users can't log in after password reset\"\n```\n\nRuns the bug fix pipeline with a mandatory pattern sweep to catch all occurrences:\n\n```\n/bug → /debug → fix → /review + /validate → /pr\n```\n\n### Common variations\n\n```bash\n/virtual-team:flow --deep Add search capability        # agent-powered analysis (thorough)\n/virtual-team:flow --auto Add simple utility           # minimal gates, stops only on failures\n/virtual-team:flow --to=plan Add notifications         # stop after planning\n/virtual-team:flow --from=implement                     # resume from implementation\n/virtual-team:flow --fix BUG-003                       # bug already documented, start at debug\n/virtual-team:flow --fix --quick \"typo in header\"      # skip bug report, go straight to debug\n```\n\n---\n\n## Want More Control?\n\n`/flow` chains the pipeline automatically. You can run each step individually when you want to pause, review, or iterate between steps.\n\n### The Pipeline Steps\n\nThese are the commands that `/flow` runs under the hood. Use them directly when you want granular control:\n\n```\n/feature → /contracts → /plan → /implement → /review + /validate → /pr\n```\n\n| Step | Command | What it produces |\n|------|---------|-----------------|\n| **Spec** | `/virtual-team:feature Add password reset` | Feature spec with acceptance criteria + backlog stories |\n| **Contracts** | `/virtual-team:contracts extract docs/features/...` | API schemas in `contracts/` — locks down payload shapes before code |\n| **Plan** | `/virtual-team:plan FEAT-001` | Phased implementation plan with file references and patterns |\n| **Build** | `/virtual-team:implement FEAT-001` | Working code — picks up stories, executes plan, runs TDD |\n| **Review** | `/virtual-team:review` | Code review (quality + security + domain) against the diff |\n| **Validate** | `/virtual-team:validate FEAT-001` | Gap analysis — compares spec requirements vs actual implementation |\n| **Ship** | `/virtual-team:pr` | PR with summary, testing notes, and backlog updates |\n\n#### Example: manual step-by-step\n\n```bash\n/virtual-team:feature Add password reset via email     # spec + stories\n/virtual-team:contracts extract docs/features/...      # lock down API shapes\n/virtual-team:plan FEAT-001                            # technical plan\n/virtual-team:implement FEAT-001                       # write code (TDD enforced)\n/virtual-team:review                                   # code review\n/virtual-team:validate FEAT-001                        # spec coverage check\n/virtual-team:commit                                   # atomic commit\n/virtual-team:pr                                       # create PR\n```\n\n### Pipeline Flags\n\nThese flags work with both `/flow` and the individual pipeline commands:\n\n| Flag | Effect | Available in |\n|------|--------|-------------|\n| `--deep` | Spawn specialized agents for thorough analysis | `/feature`, `/plan`, `/implement`, `/debug`, `/flow` |\n| `--auto` | Skip confirmations, stop only on failures | `/feature`, `/plan`, `/implement`, `/flow` |\n| `--sdd` | Subagent-driven development — parallel implementation | `/implement` |\n| `--fresh` | Delete checkpoint, start from scratch | `/feature`, `/plan`, `/implement`, `/debug`, `/flow` |\n| `--phase=N` | Resume from a specific phase | `/implement` |\n\n---\n\n## Support Commands\n\nThese commands complement the pipeline. They're grouped by when you'd reach for them.\n\n### Discovery and Research\n\nUse these **before** the pipeline — when you're still exploring what to build.\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:idea Build a task management app` | Structured interview to capture a product concept. Spawns product-owner agent for market/risk analysis with `--deep`. |\n| `/virtual-team:research WebSocket libraries for Go` | Deep-dive research (market, technical, or codebase). Produces a sourced research document. |\n| `/virtual-team:proposal FEAT-001` | Business proposal with scope, timeline, and cost estimates. |\n| `/virtual-team:epic Add multilingual support` | Cross-team initiative for multi-repo products. Defines shared agreements and routes work across repos. Requires a [hub repo](docs/command-reference.md#multi-repo-setup). |\n\n### Bug Investigation\n\nUse these to investigate bugs independently of `/flow --fix`.\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:bug Users can't reset password` | Document a bug report with reproduction steps and severity. |\n| `/virtual-team:debug BUG-003` | Investigate: reproduce → trace → root cause → **mandatory pattern sweep** across the entire codebase. |\n\n### Quality and Review\n\nUse these **after** implementation — to verify and improve.\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:review` | Code review of staged/recent changes (quality + security + domain). |\n| `/virtual-team:validate FEAT-001` | Compare spec vs implementation — finds gaps, deviations, scope creep. |\n| `/virtual-team:tech-review` | Architecture health check — debt, patterns, dependencies, risks. |\n| `/virtual-team:check` | Quiz yourself on technical decisions in the current work. |\n| `/virtual-team:decisions testing` | Quick lookup: \"what did we decide about X?\" with source references. |\n\n### Git and Delivery\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:commit` | Clean, atomic commit following project conventions. |\n| `/virtual-team:pr` | Create PR with summary, testing notes, and backlog updates. Supports `--draft`, `--rebase`, `--base=develop`. |\n| `/virtual-team:worktree` | Create, remove, or clean up git worktrees. |\n\n### Session and Project Management\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:status` | Morning standup — project state, backlog health, what to work on next. |\n| `/virtual-team:handoff` | End a session cleanly — captures exact state for the next session. |\n| `/virtual-team:refine docs/features/...` | Iterate on an existing spec, plan, or document with new context. |\n| `/virtual-team:docs` | Generate project documentation — setup guides, config references, runbooks. |\n\n### Maintenance\n\n| Command | What it does |\n|---------|-------------|\n| `/virtual-team:start` | Initialize or re-initialize project structure and `stack.md`. |\n| `/virtual-team:update-workflow` | Pull latest commands, skills, and agents from the template repo. |\n\n---\n\n## How It Works\n\n### Skills (coding standards)\n\nSkills are domain-specific coding standards that load automatically based on what you're working on:\n\n- **Behavioral skills** (always active): TDD enforcement, grounded-claims, verification-before-completion, code review reception\n- **Domain skills** (loaded by context): API design, UI design, data layer, service layer\n- **Stack skills** (you create these): Project-specific patterns matched via `stack.md`\n\n### Agents (specialized sub-agents)\n\n8 read-only agents that analyze and recommend — they never write code:\n\n| Agent | Role | Spawned by |\n|-------|------|-----------|\n| `product-owner` | Market analysis, YAGNI checks | `/idea`, `/feature`, `/epic` |\n| `software-architect` | Architecture decisions, dependency gatekeeper | `/plan`, `/epic` |\n| `security-reviewer` | Security vulnerability scanning | `/review` |\n| `pattern-finder` | Find existing code patterns as templates | `/plan`, `/implement` |\n| `codebase-analyzer` | Trace data flow and system behavior | `/debug`, `/plan` |\n| `codebase-locator` | Find relevant files by area/concern | `/feature`, `/plan` |\n| `docs-locator` | Find docs, plans, decisions by topic | `/feature`, `/plan` |\n| `web-researcher` | External research with source attribution | `/research`, `/idea` |\n\nAgents are spawned with the `--deep` flag. Without it, commands use direct tools (faster, cheaper).\n\n### Hooks (automatic enforcement)\n\nTwo hooks run automatically — no setup needed:\n\n- **SessionStart**: Loads skill-awareness so behavioral skills activate based on context\n- **PreToolUse** (on Edit/Write): Checks TDD discipline and verification discipline before code changes\n\n---\n\n## Further Reading\n\n- **[Command Reference](docs/command-reference.md)** — Full flag reference, story groups, knowledge checks, backlog lifecycle, multi-repo setup, skill customization, and design principles\n- **[Workflow Review](docs/workflow-review-report.md)** — Independent assessment of the plugin's strengths, friction points, and token efficiency\n\n## File Structure\n\n```\ncommands/       — 26 workflow commands (slash commands)\nskills/workflow-* — Codex adapters for the canonical workflows\nskills/         — 15 coding standards (domain, behavioral, backlog)\nagents/         — 8 specialized sub-agents (read-only)\nhooks/          — Automatic enforcement (SessionStart, PreToolUse)\nexamples/       — CLAUDE.md templates for hub and service repos\ntests/          — Structural validation (frontmatter, references)\n.codex-plugin/  — Codex plugin manifest\n```\n",
  "bytes": 14976,
  "sha": "2f7b4f9616de964d9a202a6f8c75067dfb836d6ddc3da81428cd2b4672adb3d1",
  "repo_slug": "ovargas/virtual-team",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_ovargas_virtual_team_109a5173/readme"
}