virtual-team

Document a bug report with reproduction steps, severity, and expected behavior

Knowledge check — quiz the developer on technical decisions in the current work

Create clean, atomic git commits following project conventions

Extract, define, and validate API contracts (payloads, models, events) as concrete schema files

Investigate a bug — reproduce it, trace through code, find the root cause, and document findings

Query project conventions, architectural decisions, and design patterns — quick answers with source references

Document a project — setup guides, config references, runbooks, and operational notes

Define a product-level initiative in the hub, identify affected repos, and capture cross-team agreements

Capture, research, and spec a feature for an existing product — from rough idea to actionable stories

Bug fix pipeline for /vt-flow --fix mode. Loaded conditionally by flow.md when --fix is passed.

Run the full pipeline (feature → contracts → plan → implement → review + validate → pr) with interactive gates between steps. Use --fix for the bug fix pipeline (bug → debug → fix → review + validate → pr).

Capture session state for clean context transfer between sessions

Capture, refine, and document a product idea through structured interview and optional research

Execute a technical implementation plan phase by phase, with verification at each step

Create a detailed technical implementation plan from an approved feature spec

Create a pull request with proper title, summary, and testing notes

Generate a detailed business proposal from an idea brief or feature breakdown — scope, timeline, infrastructure, and pricing

Revisit and sharpen an existing idea brief or feature spec with new context

Investigate a question thoroughly — market, technical, or codebase — and document findings

CCode review of staged or recent changes against patterns, security, and acceptance criteria

Initialize a repository with stack definition, project structure, and team configuration

Morning standup — summarize project state, backlog health, and what to work on next

Technical health check on a component, module, or the full codebase — architecture, debt, patterns, and risks

Check for plugin updates and show the current virtual-team plugin version

Compare the feature spec against the actual implementation to find gaps, missing requirements, and unmet acceptance criteria

Create, remove, or list git worktrees for branch-based parallel work

Run /virtual-team:vt-flow with --auto baked in. Same pipeline, less friction, more regret potential. All /virtual-team:vt-flow flags pass through.

Provide architectural recommendations and enforce technical decision dependencies for new features.

Research and synthesize information from the web to answer specific questions with source attribution.

Analyze and document how existing code works, tracing data flow, dependencies, and patterns.

Locate and categorize all relevant files for a given feature, component, or concept in the codebase.

Locate and categorize all relevant documents for a given topic, feature, or keyword in the project's documentation directory.

Find existing code patterns to serve as references for new work.

Analyze product ideas and features from a market, user, and value perspective.

Review code for security vulnerabilities and potential risks.

External service backlog implementation (GitHub Issues, Linear, JIRA). Used when stack.md has backlog external with a backlog_config section.

File-based backlog implementation using docs/backlog.md (bracket markers). Default when stack.md has backlog local or no backlog field.

Abstract backlog operations interface. Load this skill before any backlog read/write operation — it defines the operations that all commands reference, delegating to the active implementation (local or external).

Checkpoint protocol for resuming multi-phase commands after session interruptions

Use when writing production code — enforces dependency inversion and testable design through checkpoint questions before writing function signatures and constructors

Git conventions for branches, commits, and pull requests. Load this skill whenever creating branches, writing commit messages, or opening PRs. Trigger on any git workflow operation — commits, branches, pull requests, or merge operations.

Protocol for validating developer understanding of AI-generated technical decisions. Loaded by /vt-plan, /vt-pr, and the standalone /virtual-team:vt-check command.

Use when processing code review feedback from any source — enforces verify-before-implementing with no performative agreement

Use when starting any session — maps contexts to behavioral skills that should be active

Use when /virtual-team:vt-implement --sdd is active — defines orchestration protocol for fresh subagent per task with two-stage review

Use when implementing any feature or bugfix, before writing implementation code — enforces red-green-refactor cycle with configurable strictness

Assess work complexity and determine the right documentation ceremony level before starting the pipeline

Use before making any completion claim — enforces evidence-before-claims with no exceptions

1 hook across 1 event