Vengineer

General-purpose agent for multi-step tasks, research, and cross-domain work. Use when no specialized domain expertise is required or when task spans multiple domains. Use PROACTIVELY for open-ended searches, complex tasks requiring multiple rounds, or when domain is unclear.

Use this agent when you have a specification, plan, feature description, or technical document that needs user flow analysis and gap identification. This agent should be used proactively when: <example> Context: The user has just finished drafting a specification for OAuth implementation. user: "Here's the OAuth spec for our new integration: [OAuth spec details]" assistant: "Let me use the spec-flow-analyzer agent to analyze this OAuth specification for user flows and missing elements." <commentary> Since the user has provided a specification document, use the Task tool to launch the spec-flow-analyzer agent to identify all user flows, edge cases, and missing clarifications. </commentary> </example> <example> Context: The user is planning a new social sharing feature. user: "I'm thinking we should add social sharing to posts. Users can share to Twitter, Facebook, and LinkedIn." assistant: "This sounds like a feature specification that would benefit from flow analysis. Let me use the spec-flow-analyzer agent to map out all the user flows and identify any missing pieces." <commentary> The user is describing a new feature. Use the spec-flow-analyzer agent to analyze the feature from the user's perspective, identify all permutations, and surface questions about missing elements. </commentary> </example> <example> Context: The user has created a plan for a new onboarding flow. user: "Can you review this onboarding plan and make sure we haven't missed anything?" assistant: "I'll use the spec-flow-analyzer agent to thoroughly analyze this onboarding plan from the user's perspective." <commentary> The user is explicitly asking for review of a plan. Use the spec-flow-analyzer agent to identify all user flows, edge cases, and gaps in the specification. </commentary> </example> Call this agent when: - A user presents a feature specification, plan, or requirements document - A user asks to review or validate a design or implementation plan - A user describes a new feature or integration that needs flow analysis - After initial planning sessions to validate completeness - Before implementation begins on complex user-facing features - When stakeholders need clarity on user journeys and edge cases

Use this agent when you need to research and gather external best practices, documentation, and examples for any technology, framework, or development practice. This includes finding official documentation, community standards, well-regarded examples from open source projects, and domain-specific conventions. The agent excels at synthesizing information from multiple sources to provide comprehensive guidance on how to implement features or solve problems according to industry standards. <example>Context: User wants to know the best way to structure GitHub issues for their Rails project. user: "I need to create some GitHub issues for our project. Can you research best practices for writing good issues?" assistant: "I'll use the best-practices-researcher agent to gather comprehensive information about GitHub issue best practices, including examples from successful projects and Rails-specific conventions." <commentary>Since the user is asking for research on best practices, use the best-practices-researcher agent to gather external documentation and examples.</commentary></example> <example>Context: User is implementing a new authentication system and wants to follow security best practices. user: "We're adding JWT authentication to our Rails API. What are the current best practices?" assistant: "Let me use the best-practices-researcher agent to research current JWT authentication best practices, security considerations, and Rails-specific implementation patterns." <commentary>The user needs research on best practices for a specific technology implementation, so the best-practices-researcher agent is appropriate.</commentary></example>

Use this agent when you need to gather comprehensive documentation and best practices for frameworks, libraries, or dependencies in your project. This includes fetching official documentation, exploring source code, identifying version-specific constraints, and understanding implementation patterns. <example>Context: The user needs to understand how to properly implement a new feature using a specific library. user: "I need to implement file uploads using Active Storage" assistant: "I'll use the framework-docs-researcher agent to gather comprehensive documentation about Active Storage" <commentary>Since the user needs to understand a framework/library feature, use the framework-docs-researcher agent to collect all relevant documentation and best practices.</commentary></example> <example>Context: The user is troubleshooting an issue with a gem. user: "Why is the turbo-rails gem not working as expected?" assistant: "Let me use the framework-docs-researcher agent to investigate the turbo-rails documentation and source code" <commentary>The user needs to understand library behavior, so the framework-docs-researcher agent should be used to gather documentation and explore the gem's source.</commentary></example>

Use this agent when you need to understand the historical context and evolution of code changes, trace the origins of specific code patterns, identify key contributors and their expertise areas, or analyze patterns in commit history. This agent excels at archaeological analysis of git repositories to provide insights about code evolution and development patterns. <example>Context: The user wants to understand the history and evolution of recently modified files. user: "I've just refactored the authentication module. Can you analyze the historical context?" assistant: "I'll use the git-history-analyzer agent to examine the evolution of the authentication module files." <commentary>Since the user wants historical context about code changes, use the git-history-analyzer agent to trace file evolution, identify contributors, and extract patterns from the git history.</commentary></example> <example>Context: The user needs to understand why certain code patterns exist. user: "Why does this payment processing code have so many try-catch blocks?" assistant: "Let me use the git-history-analyzer agent to investigate the historical context of these error handling patterns." <commentary>The user is asking about the reasoning behind code patterns, which requires historical analysis to understand past issues and fixes.</commentary></example>

Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices. Examples: - <example> Context: User wants to understand a new repository's structure and conventions before contributing. user: "I need to understand how this project is organized and what patterns they use" assistant: "I'll use the repo-research-analyst agent to conduct a thorough analysis of the repository structure and patterns." <commentary> Since the user needs comprehensive repository research, use the repo-research-analyst agent to examine all aspects of the project. </commentary> </example> - <example> Context: User is preparing to create a GitHub issue and wants to follow project conventions. user: "Before I create this issue, can you check what format and labels this project uses?" assistant: "Let me use the repo-research-analyst agent to examine the repository's issue patterns and guidelines." <commentary> The user needs to understand issue formatting conventions, so use the repo-research-analyst agent to analyze existing issues and templates. </commentary> </example> - <example> Context: User is implementing a new feature and wants to follow existing patterns. user: "I want to add a new service object - what patterns does this codebase use?" assistant: "I'll use the repo-research-analyst agent to search for existing implementation patterns in the codebase." <commentary> Since the user needs to understand implementation patterns, use the repo-research-analyst agent to search and analyze the codebase. </commentary> </example>

Use this agent when you need to analyze code changes from an architectural perspective, evaluate system design decisions, or ensure that modifications align with established architectural patterns. This includes reviewing pull requests for architectural compliance, assessing the impact of new features on system structure, or validating that changes maintain proper component boundaries and design principles. <example>Context: The user wants to review recent code changes for architectural compliance. user: "I just refactored the authentication service to use a new pattern" assistant: "I'll use the architecture-strategist agent to review these changes from an architectural perspective" <commentary>Since the user has made structural changes to a service, use the architecture-strategist agent to ensure the refactoring aligns with system architecture.</commentary></example><example>Context: The user is adding a new microservice to the system. user: "I've added a new notification service that integrates with our existing services" assistant: "Let me analyze this with the architecture-strategist agent to ensure it fits properly within our system architecture" <commentary>New service additions require architectural review to verify proper boundaries and integration patterns.</commentary></example>

You are Big Head bobo (大头啵啵), a super senior C++ developer robot dog with impeccable taste and an exceptionally high bar for C++ code quality. You review all code changes with a keen eye for correctness, lifetime safety, performance, clarity, and long-term maintainability. Baseline is **C++17**, and you actively encourage modern, safe C++ patterns.

Use this agent when you need to review Python code changes with an extremely high quality bar. This agent should be invoked after implementing features, modifying existing code, or creating new Python modules. The agent applies Big Head bobo's strict Python conventions and taste preferences to ensure code meets exceptional standards. Examples: - <example> Context: The user has just implemented a new FastAPI endpoint. user: "I've added a new user registration endpoint" assistant: "I've implemented the registration endpoint. Now let me have Big Head bobo review this code to ensure it meets our quality standards." <commentary> Since new endpoint code was written, use the bobo-python-reviewer agent to apply Big Head bobo's strict Python conventions and quality checks. </commentary> </example> - <example> Context: The user has refactored an existing service class. user: "Please refactor the EmailService class to handle attachments" assistant: "I've refactored the EmailService to handle attachments." <commentary> After modifying existing code, especially services, use bobo-python-reviewer to ensure the changes meet Big Head bobo's high bar for code quality. </commentary> assistant: "Let me have Big Head bobo review these changes to the EmailService." </example> - <example> Context: The user has created new utility functions. user: "Create a data validation module" assistant: "I've created the data validation module." <commentary> New modules should be reviewed by bobo-python-reviewer to check Pythonic patterns, type hints, and best practices. </commentary> assistant: "I'll have Big Head bobo review this module to ensure it follows our conventions." </example>

Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles. Examples: <example>Context: The user has just implemented a new feature and wants to ensure it's as simple as possible. user: "I've finished implementing the user authentication system" assistant: "Great! Let me review the implementation for simplicity and minimalism using the code-simplicity-reviewer agent" <commentary>Since implementation is complete, use the code-simplicity-reviewer agent to identify simplification opportunities.</commentary></example> <example>Context: The user has written complex business logic and wants to simplify it. user: "I think this order processing logic might be overly complex" assistant: "I'll use the code-simplicity-reviewer agent to analyze the complexity and suggest simplifications" <commentary>The user is explicitly concerned about complexity, making this a perfect use case for the code-simplicity-reviewer.</commentary></example>

Use this agent when you need to analyze code for design patterns, anti-patterns, naming conventions, and code duplication. This agent excels at identifying architectural patterns, detecting code smells, and ensuring consistency across the codebase. <example>Context: The user wants to analyze their codebase for patterns and potential issues. user: "Can you check our codebase for design patterns and anti-patterns?" assistant: "I'll use the pattern-recognition-specialist agent to analyze your codebase for patterns, anti-patterns, and code quality issues." <commentary>Since the user is asking for pattern analysis and code quality review, use the Task tool to launch the pattern-recognition-specialist agent.</commentary></example><example>Context: After implementing a new feature, the user wants to ensure it follows established patterns. user: "I just added a new service layer. Can we check if it follows our existing patterns?" assistant: "Let me use the pattern-recognition-specialist agent to analyze the new service layer and compare it with existing patterns in your codebase." <commentary>The user wants pattern consistency verification, so use the pattern-recognition-specialist agent to analyze the code.</commentary></example>

Use this agent when you need to analyze code for performance issues, optimize algorithms, identify bottlenecks, or ensure scalability. This includes reviewing database queries, memory usage, caching strategies, and overall system performance. The agent should be invoked after implementing features or when performance concerns arise. <example> Context: The user has just implemented a new feature that processes user data. user: "I've implemented the user analytics feature. Can you check if it will scale?" assistant: "I'll use the performance-oracle agent to analyze the scalability and performance characteristics of your implementation." <commentary> Since the user is concerned about scalability, use the Task tool to launch the performance-oracle agent to analyze the code for performance issues. </commentary> </example> <example> Context: The user is experiencing slow API responses. user: "The API endpoint for fetching reports is taking over 2 seconds to respond" assistant: "Let me invoke the performance-oracle agent to identify the performance bottlenecks in your API endpoint." <commentary> The user has a performance issue, so use the performance-oracle agent to analyze and identify bottlenecks. </commentary> </example> <example> Context: After writing a data processing algorithm. user: "I've written a function to match users based on their preferences" assistant: "I've implemented the matching function. Now let me use the performance-oracle agent to ensure it will scale efficiently." <commentary> After implementing an algorithm, proactively use the performance-oracle agent to verify its performance characteristics. </commentary> </example>

Capture architectural decisions as permanent, sequentially-numbered Architecture Decision Records in docs/adr/

Look up academic papers on AlphaXiv — given an arXiv ID or URL, fetch a structured AI-generated overview (problem, approach, key insights, results) and optionally save annotated notes to docs/research/.

Orchestrate the full planning pipeline (Sketch → Spec → Plan → ADR) for a feature, resuming automatically from wherever the pipeline left off

Ask a question about the codebase using parallel exploration agents

Decompose one or more plan files into actionable GitHub issues — one issue per concrete implementation task (~1-4h of work) with title, body, labels, and effort estimate.

Scan all docs/ markdown files for broken cross-references, validate frontmatter links, detect orphaned documents, and offer to fix inconsistencies.

Clarify requirements by asking targeted questions to reduce ambiguity before planning

Review local git changes, split them into clean commits, and write clear conventional commit messages. Use when the user asks to commit work, prepare commits, or turn a diff into one or more focused commits.

Capture solved problems as categorized documentation with YAML frontmatter for fast lookup

Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.

Draft and open high-quality pull requests in Chinese with clear titles, structured descriptions (including file-level changes/rationale and impact scope), and a Mermaid change diagram. Use when the user asks to create a PR, write a PR description, or prepare a branch for review.

Enhance existing plans with parallel research agents for maximum depth and grounding

Use this skill when you need documentation for a third-party library, SDK, or API before writing code that uses it — for example, "use the OpenAI API", "call the Stripe API", "use the Anthropic SDK", "query Pinecone", or any time the user asks you to write code against an external service and you need current API reference. Fetch the docs with chub before answering, rather than relying on training knowledge.

This skill manages Git worktrees for isolated parallel development. It handles creating, listing, switching, and cleaning up worktrees with a simple interactive interface, following KISS principles.

Fix incorrect SKILL.md files when a skill has wrong instructions or outdated API references

Expert guidance for creating Claude Code hooks. Use when configuring hooks in settings files, creating hook scripts, or implementing hook-based workflows for tool interception, validation, or automation.

Free-form collaborative brainstorm: explore an idea through dialogue, propose 2-3 approaches, then produce a docs/sketches/ design document. Use BEFORE medium-plan or turn2spec when the idea is still rough. For a more structured plan with research agents, use medium-plan instead.

Transform feature descriptions into well-structured project plans following conventions

Get feedback from specialized reviewers on plans before implementation

Generate concise Chinese PR summary from git changes

Report a bug or request a feature in the Vengineer plugin

Resolve all TODO comments using parallel processing

Perform exhaustive code reviews using multi-agent analysis across 13+ specialized reviewer agents

Transform design docs, ADRs, or rough plans into proper feature specifications

Execute work plans efficiently while maintaining quality and finishing features